﻿#ifndef _MSC_VER

#include <string.h>

extern inline const char * strerr(int err) {
    return strerror(err);
}

#else

#include <winerror.h>

#define DWORD int

extern const char * strerr(int err) {
    switch (err) {
    case ERROR_SUCCESS                                                            : return "The operation completed successfully";
    case ERROR_INVALID_FUNCTION                                                   : return "Incorrect function";
    case ERROR_FILE_NOT_FOUND                                                     : return "The system cannot find the file specified";
    case ERROR_PATH_NOT_FOUND                                                     : return "The system cannot find the path specified";
    case ERROR_TOO_MANY_OPEN_FILES                                                : return "The system cannot open the file";
    case ERROR_ACCESS_DENIED                                                      : return "Access is denied";
    case ERROR_INVALID_HANDLE                                                     : return "The handle is invalid";
    case ERROR_ARENA_TRASHED                                                      : return "The storage control blocks were destroyed";
    case ERROR_NOT_ENOUGH_MEMORY                                                  : return "Not enough storage is available to process this command";
    case ERROR_INVALID_BLOCK                                                      : return "The storage control block address is invalid";
    case ERROR_BAD_ENVIRONMENT                                                    : return "The environment is incorrect";
    case ERROR_BAD_FORMAT                                                         : return "An attempt was made to load a program with an incorrect format";
    case ERROR_INVALID_ACCESS                                                     : return "The access code is invalid";
    case ERROR_INVALID_DATA                                                       : return "The data is invalid";
    case ERROR_OUTOFMEMORY                                                        : return "Not enough storage is available to complete this operation";
    case ERROR_INVALID_DRIVE                                                      : return "The system cannot find the drive specified";
    case ERROR_CURRENT_DIRECTORY                                                  : return "The directory cannot be removed";
    case ERROR_NOT_SAME_DEVICE                                                    : return "The system cannot move the file to a different disk drive";
    case ERROR_NO_MORE_FILES                                                      : return "There are no more files";
    case ERROR_WRITE_PROTECT                                                      : return "The media is write protected";
    case ERROR_BAD_UNIT                                                           : return "The system cannot find the device specified";
    case ERROR_NOT_READY                                                          : return "The device is not ready";
    case ERROR_BAD_COMMAND                                                        : return "The device does not recognize the command";
    case ERROR_CRC                                                                : return "Data error (cyclic redundancy check)";
    case ERROR_BAD_LENGTH                                                         : return "The program issued a command but the command length is incorrect";
    case ERROR_SEEK                                                               : return "The drive cannot locate a specific area or track on the disk";
    case ERROR_NOT_DOS_DISK                                                       : return "The specified disk or diskette cannot be accessed";
    case ERROR_SECTOR_NOT_FOUND                                                   : return "The drive cannot find the sector requested";
    case ERROR_OUT_OF_PAPER                                                       : return "The printer is out of paper";
    case ERROR_WRITE_FAULT                                                        : return "The system cannot write to the specified device";
    case ERROR_READ_FAULT                                                         : return "The system cannot read from the specified device";
    case ERROR_GEN_FAILURE                                                        : return "A device attached to the system is not functioning";
    case ERROR_SHARING_VIOLATION                                                  : return "The process cannot access the file because it is being used by another process";
    case ERROR_LOCK_VIOLATION                                                     : return "The process cannot access the file because another process has locked a portion of the file";
    case ERROR_WRONG_DISK                                                         : return "The wrong diskette is in the drive";
    case ERROR_SHARING_BUFFER_EXCEEDED                                            : return "Too many files opened for sharing";
    case ERROR_HANDLE_EOF                                                         : return "Reached the end of the file";
    case ERROR_HANDLE_DISK_FULL                                                   : return "The disk is full";
    case ERROR_NOT_SUPPORTED                                                      : return "The request is not supported";
    case ERROR_REM_NOT_LIST                                                       : return "Windows cannot find the network path. Verify that the network path is correct and the destination computer is not busy or turned off. If Windows still cannot find the network path, contact your network administrator";
    case ERROR_DUP_NAME                                                           : return "You were not connected because a duplicate name exists on the network. If joining a domain, go to System in Control Panel to change the computer name and try again. If joining a workgroup, choose another workgroup name";
    case ERROR_BAD_NETPATH                                                        : return "The network path was not found";
    case ERROR_NETWORK_BUSY                                                       : return "The network is busy";
    case ERROR_DEV_NOT_EXIST                                                      : return "The specified network resource or device is no longer available";
    case ERROR_TOO_MANY_CMDS                                                      : return "The network BIOS command limit has been reached";
    case ERROR_ADAP_HDW_ERR                                                       : return "A network adapter hardware error occurred";
    case ERROR_BAD_NET_RESP                                                       : return "The specified server cannot perform the requested operation";
    case ERROR_UNEXP_NET_ERR                                                      : return "An unexpected network error occurred";
    case ERROR_BAD_REM_ADAP                                                       : return "The remote adapter is not compatible";
    case ERROR_PRINTQ_FULL                                                        : return "The printer queue is full";
    case ERROR_NO_SPOOL_SPACE                                                     : return "Space to store the file waiting to be printed is not available on the server";
    case ERROR_PRINT_CANCELLED                                                    : return "Your file waiting to be printed was deleted";
    case ERROR_NETNAME_DELETED                                                    : return "The specified network name is no longer available";
    case ERROR_NETWORK_ACCESS_DENIED                                              : return "Network access is denied";
    case ERROR_BAD_DEV_TYPE                                                       : return "The network resource type is not correct";
    case ERROR_BAD_NET_NAME                                                       : return "The network name cannot be found";
    case ERROR_TOO_MANY_NAMES                                                     : return "The name limit for the local computer network adapter card was exceeded";
    case ERROR_TOO_MANY_SESS                                                      : return "The network BIOS session limit was exceeded";
    case ERROR_SHARING_PAUSED                                                     : return "The remote server has been paused or is in the process of being started";
    case ERROR_REQ_NOT_ACCEP                                                      : return "No more connections can be made to this remote computer at this time because there are already as many connections as the computer can accept";
    case ERROR_REDIR_PAUSED                                                       : return "The specified printer or disk device has been paused";
    case ERROR_FILE_EXISTS                                                        : return "The file exists";
    case ERROR_CANNOT_MAKE                                                        : return "The directory or file cannot be created";
    case ERROR_FAIL_I24                                                           : return "Fail on INT 24";
    case ERROR_OUT_OF_STRUCTURES                                                  : return "Storage to process this request is not available";
    case ERROR_ALREADY_ASSIGNED                                                   : return "The local device name is already in use";
    case ERROR_INVALID_PASSWORD                                                   : return "The specified network password is not correct";
    case ERROR_INVALID_PARAMETER                                                  : return "The parameter is incorrect";
    case ERROR_NET_WRITE_FAULT                                                    : return "A write fault occurred on the network";
    case ERROR_NO_PROC_SLOTS                                                      : return "The system cannot start another process at this time";
    case ERROR_TOO_MANY_SEMAPHORES                                                : return "Cannot create another system semaphore";
    case ERROR_EXCL_SEM_ALREADY_OWNED                                             : return "The exclusive semaphore is owned by another process";
    case ERROR_SEM_IS_SET                                                         : return "The semaphore is set and cannot be closed";
    case ERROR_TOO_MANY_SEM_REQUESTS                                              : return "The semaphore cannot be set again";
    case ERROR_INVALID_AT_INTERRUPT_TIME                                          : return "Cannot request exclusive semaphores at interrupt time";
    case ERROR_SEM_OWNER_DIED                                                     : return "The previous ownership of this semaphore has ended";
    case ERROR_SEM_USER_LIMIT                                                     : return "Insert the diskette for drive %%1";
    case ERROR_DISK_CHANGE                                                        : return "The program stopped because an alternate diskette was not inserted";
    case ERROR_DRIVE_LOCKED                                                       : return "The disk is in use or locked by another process";
    case ERROR_BROKEN_PIPE                                                        : return "The pipe has been ended";
    case ERROR_OPEN_FAILED                                                        : return "The system cannot open the device or file specified";
    case ERROR_BUFFER_OVERFLOW                                                    : return "The file name is too long";
    case ERROR_DISK_FULL                                                          : return "There is not enough space on the disk";
    case ERROR_NO_MORE_SEARCH_HANDLES                                             : return "No more internal file identifiers available";
    case ERROR_INVALID_TARGET_HANDLE                                              : return "The target internal file identifier is incorrect";
    case ERROR_INVALID_CATEGORY                                                   : return "The IOCTL call made by the application program is not correct";
    case ERROR_INVALID_VERIFY_SWITCH                                              : return "The verify-on-write switch parameter value is not correct";
    case ERROR_BAD_DRIVER_LEVEL                                                   : return "The system does not support the command requested";
    case ERROR_CALL_NOT_IMPLEMENTED                                               : return "This function is not supported on this system";
    case ERROR_SEM_TIMEOUT                                                        : return "The semaphore timeout period has expired";
    case ERROR_INSUFFICIENT_BUFFER                                                : return "The data area passed to a system call is too small";
    case ERROR_INVALID_NAME                                                       : return "The filename, directory name, or volume label syntax is incorrect";
    case ERROR_INVALID_LEVEL                                                      : return "The system call level is not correct";
    case ERROR_NO_VOLUME_LABEL                                                    : return "The disk has no volume label";
    case ERROR_MOD_NOT_FOUND                                                      : return "The specified module could not be found";
    case ERROR_PROC_NOT_FOUND                                                     : return "The specified procedure could not be found";
    case ERROR_WAIT_NO_CHILDREN                                                   : return "There are no child processes to wait for";
    case ERROR_CHILD_NOT_COMPLETE                                                 : return "The %%1 application cannot be run in Win32 mode";
    case ERROR_DIRECT_ACCESS_HANDLE                                               : return "Attempt to use a file handle to an open disk partition for an operation other than raw disk I/O";
    case ERROR_NEGATIVE_SEEK                                                      : return "An attempt was made to move the file pointer before the beginning of the file";
    case ERROR_SEEK_ON_DEVICE                                                     : return "The file pointer cannot be set on the specified device or file";
    case ERROR_IS_JOIN_TARGET                                                     : return "A JOIN or SUBST command cannot be used for a drive that contains previously joined drives";
    case ERROR_IS_JOINED                                                          : return "An attempt was made to use a JOIN or SUBST command on a drive that has already been joined";
    case ERROR_IS_SUBSTED                                                         : return "An attempt was made to use a JOIN or SUBST command on a drive that has already been substituted";
    case ERROR_NOT_JOINED                                                         : return "The system tried to delete the JOIN of a drive that is not joined";
    case ERROR_NOT_SUBSTED                                                        : return "The system tried to delete the substitution of a drive that is not substituted";
    case ERROR_JOIN_TO_JOIN                                                       : return "The system tried to join a drive to a directory on a joined drive";
    case ERROR_SUBST_TO_SUBST                                                     : return "The system tried to substitute a drive to a directory on a substituted drive";
    case ERROR_JOIN_TO_SUBST                                                      : return "The system tried to join a drive to a directory on a substituted drive";
    case ERROR_SUBST_TO_JOIN                                                      : return "The system tried to SUBST a drive to a directory on a joined drive";
    case ERROR_BUSY_DRIVE                                                         : return "The system cannot perform a JOIN or SUBST at this time";
    case ERROR_SAME_DRIVE                                                         : return "The system cannot join or substitute a drive to or for a directory on the same drive";
    case ERROR_DIR_NOT_ROOT                                                       : return "The directory is not a subdirectory of the root directory";
    case ERROR_DIR_NOT_EMPTY                                                      : return "The directory is not empty";
    case ERROR_IS_SUBST_PATH                                                      : return "The path specified is being used in a substitute";
    case ERROR_IS_JOIN_PATH                                                       : return "Not enough resources are available to process this command";
    case ERROR_PATH_BUSY                                                          : return "The path specified cannot be used at this time";
    case ERROR_IS_SUBST_TARGET                                                    : return "An attempt was made to join or substitute a drive for which a directory on the drive is the target of a previous substitute";
    case ERROR_SYSTEM_TRACE                                                       : return "System trace information was not specified in your CONFIG.SYS file, or tracing is disallowed";
    case ERROR_INVALID_EVENT_COUNT                                                : return "The number of specified semaphore event for DosMuxSemWait is not correct";
    case ERROR_TOO_MANY_MUXWAITERS                                                : return "DosMuxSemWait did not execute; too many semaphores are already set";
    case ERROR_INVALID_LIST_FORMAT                                                : return "The DosMuxSemWait list is not correct";
    case ERROR_LABEL_TOO_LONG                                                     : return "The volume label you entered exceeds the label character limit of the target file system";
    case ERROR_TOO_MANY_TCBS                                                      : return "Cannot create another thread";
    case ERROR_SIGNAL_REFUSED                                                     : return "The recipient process has refused the signal";
    case ERROR_DISCARDED                                                          : return "The segment is already discarded and cannot be locked";
    case ERROR_NOT_LOCKED                                                         : return "The segment is already unlocked";
    case ERROR_BAD_THREADID_ADDR                                                  : return "The address for the thread ID is not correct";
    case ERROR_BAD_ARGUMENTS                                                      : return "One or more arguments are not correct";
    case ERROR_BAD_PATHNAME                                                       : return "The specified path is invalid";
    case ERROR_SIGNAL_PENDING                                                     : return "A signal is already pending";
    case ERROR_MAX_THRDS_REACHED                                                  : return "No more threads can be created in the system";
    case ERROR_LOCK_FAILED                                                        : return "Unable to lock a region of a file";
    case ERROR_BUSY                                                               : return "The requested resource is in use";
    case ERROR_DEVICE_SUPPORT_IN_PROGRESS                                         : return "Device's command support detection is in progress";
    case ERROR_CANCEL_VIOLATION                                                   : return "A lock request was not outstanding for the supplied cancel region";
    case ERROR_ATOMIC_LOCKS_NOT_SUPPORTED                                         : return "The file system does not support atomic changes to the lock type";
    case ERROR_INVALID_SEGMENT_NUMBER                                             : return "The system detected a segment number that was not correct";
    case ERROR_INVALID_ORDINAL                                                    : return "The operating system cannot run %%1";
    case ERROR_ALREADY_EXISTS                                                     : return "Cannot create a file when that file already exists";
    case ERROR_INVALID_FLAG_NUMBER                                                : return "The flag passed is not correct";
    case ERROR_SEM_NOT_FOUND                                                      : return "The specified system semaphore name was not found";
    case ERROR_INVALID_STARTING_CODESEG                                           : return "The operating system cannot run %%1";
    case ERROR_INVALID_STACKSEG                                                   : return "The operating system cannot run %%1";
    case ERROR_INVALID_MODULETYPE                                                 : return "The operating system cannot run %%1";
    case ERROR_INVALID_EXE_SIGNATURE                                              : return "Cannot run %%1 in Win32 mode";
    case ERROR_EXE_MARKED_INVALID                                                 : return "The operating system cannot run %%1";
    case ERROR_BAD_EXE_FORMAT                                                     : return "%1 is not a valid Win32 application";
    case ERROR_ITERATED_DATA_EXCEEDS_64k                                          : return "The operating system cannot run %%1";
    case ERROR_INVALID_MINALLOCSIZE                                               : return "The operating system cannot run %%1";
    case ERROR_DYNLINK_FROM_INVALID_RING                                          : return "The operating system cannot run this application program";
    case ERROR_IOPL_NOT_ENABLED                                                   : return "The operating system is not presently configured to run this application";
    case ERROR_INVALID_SEGDPL                                                     : return "The operating system cannot run %%1";
    case ERROR_AUTODATASEG_EXCEEDS_64k                                            : return "The operating system cannot run this application program";
    case ERROR_RING2SEG_MUST_BE_MOVABLE                                           : return "The code segment cannot be greater than or equal to 64K";
    case ERROR_RELOC_CHAIN_XEEDS_SEGLIM                                           : return "The operating system cannot run %%1";
    case ERROR_INFLOOP_IN_RELOC_CHAIN                                             : return "The operating system cannot run %%1";
    case ERROR_ENVVAR_NOT_FOUND                                                   : return "The system could not find the environment option that was entered";
    case ERROR_NO_SIGNAL_SENT                                                     : return "No process in the command subtree has a signal handler";
    case ERROR_FILENAME_EXCED_RANGE                                               : return "The filename or extension is too long";
    case ERROR_RING2_STACK_IN_USE                                                 : return "The ring 2 stack is in use";
    case ERROR_META_EXPANSION_TOO_LONG                                            : return "The global filename characters, * or ?, are entered incorrectly or too many global filename characters are specified";
    case ERROR_INVALID_SIGNAL_NUMBER                                              : return "The signal being posted is not correct";
    case ERROR_THREAD_1_INACTIVE                                                  : return "The signal handler cannot be set";
    case ERROR_LOCKED                                                             : return "The segment is locked and cannot be reallocated";
    case ERROR_TOO_MANY_MODULES                                                   : return "Too many dynamic-link modules are attached to this program or dynamic-link module";
    case ERROR_NESTING_NOT_ALLOWED                                                : return "Cannot nest calls to LoadModule";
    case ERROR_EXE_MACHINE_TYPE_MISMATCH                                          : return "This version of %%1 is not compatible with the version of Windows you're running. Check your computer's system information and then contact the software publisher";
    case ERROR_EXE_CANNOT_MODIFY_SIGNED_BINARY                                    : return "The image file %%1 is signed, unable to modify";
    case ERROR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY                             : return "The image file %%1 is strong signed, unable to modify";
    case ERROR_FILE_CHECKED_OUT                                                   : return "This file is checked out or locked for editing by another user";
    case ERROR_CHECKOUT_REQUIRED                                                  : return "The file must be checked out before saving changes";
    case ERROR_BAD_FILE_TYPE                                                      : return "The file type being saved or retrieved has been blocked";
    case ERROR_FILE_TOO_LARGE                                                     : return "The file size exceeds the limit allowed and cannot be saved";
    case ERROR_FORMS_AUTH_REQUIRED                                                : return "Access Denied. Before opening files in this location, you must first add the web site to your trusted sites list, browse to the web site, and select the option to login automatically";
    case ERROR_VIRUS_INFECTED                                                     : return "Operation did not complete successfully because the file contains a virus or potentially unwanted software";
    case ERROR_VIRUS_DELETED                                                      : return "This file contains a virus or potentially unwanted software and cannot be opened. Due to the nature of this virus or potentially unwanted software, the file has been removed from this location";
    case ERROR_PIPE_LOCAL                                                         : return "The pipe is local";
    case ERROR_BAD_PIPE                                                           : return "The pipe state is invalid";
    case ERROR_PIPE_BUSY                                                          : return "All pipe instances are busy";
    case ERROR_NO_DATA                                                            : return "The pipe is being closed";
    case ERROR_PIPE_NOT_CONNECTED                                                 : return "No process is on the other end of the pipe";
    case ERROR_MORE_DATA                                                          : return "More data is available";
    case ERROR_NO_WORK_DONE                                                       : return "The action requested resulted in no work being done. Error-style clean-up has been performed";
    case ERROR_VC_DISCONNECTED                                                    : return "The session was canceled";
    case ERROR_INVALID_EA_NAME                                                    : return "The specified extended attribute name was invalid";
    case ERROR_EA_LIST_INCONSISTENT                                               : return "The extended attributes are inconsistent";
    case WAIT_TIMEOUT                                                             : return "The wait operation timed out";
    case ERROR_NO_MORE_ITEMS                                                      : return "No more data is available";
    case ERROR_CANNOT_COPY                                                        : return "The copy functions cannot be used";
    case ERROR_DIRECTORY                                                          : return "The directory name is invalid";
    case ERROR_EAS_DIDNT_FIT                                                      : return "The extended attributes did not fit in the buffer";
    case ERROR_EA_FILE_CORRUPT                                                    : return "The extended attribute file on the mounted file system is corrupt";
    case ERROR_EA_TABLE_FULL                                                      : return "The extended attribute table file is full";
    case ERROR_INVALID_EA_HANDLE                                                  : return "The specified extended attribute handle is invalid";
    case ERROR_EAS_NOT_SUPPORTED                                                  : return "The mounted file system does not support extended attributes";
    case ERROR_NOT_OWNER                                                          : return "Attempt to release mutex not owned by caller";
    case ERROR_TOO_MANY_POSTS                                                     : return "Too many posts were made to a semaphore";
    case ERROR_PARTIAL_COPY                                                       : return "Only part of a ReadProcessMemory or WriteProcessMemory request was completed";
    case ERROR_OPLOCK_NOT_GRANTED                                                 : return "The oplock request is denied";
    case ERROR_INVALID_OPLOCK_PROTOCOL                                            : return "An invalid oplock acknowledgment was received by the system";
    case ERROR_DISK_TOO_FRAGMENTED                                                : return "The volume is too fragmented to complete this operation";
    case ERROR_DELETE_PENDING                                                     : return "The file cannot be opened because it is in the process of being deleted";
    case ERROR_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING               : return "Short name settings may not be changed on this volume due to the global registry setting";
    case ERROR_SHORT_NAMES_NOT_ENABLED_ON_VOLUME                                  : return "Short names are not enabled on this volume";
    case ERROR_SECURITY_STREAM_IS_INCONSISTENT                                    : return "The security stream for the given volume is in an inconsistent state";
    case ERROR_INVALID_LOCK_RANGE                                                 : return "A requested file lock operation cannot be processed due to an invalid byte range";
    case ERROR_IMAGE_SUBSYSTEM_NOT_PRESENT                                        : return "The subsystem needed to support the image type is not present";
    case ERROR_NOTIFICATION_GUID_ALREADY_DEFINED                                  : return "The specified file already has a notification GUID associated with it";
    case ERROR_INVALID_EXCEPTION_HANDLER                                          : return "An invalid exception handler routine has been detected";
    case ERROR_DUPLICATE_PRIVILEGES                                               : return "Duplicate privileges were specified for the token";
    case ERROR_NO_RANGES_PROCESSED                                                : return "No ranges for the specified operation were able to be processed";
    case ERROR_NOT_ALLOWED_ON_SYSTEM_FILE                                         : return "Operation is not allowed on a file system internal file";
    case ERROR_DISK_RESOURCES_EXHAUSTED                                           : return "The physical resources of this disk have been exhausted";
    case ERROR_INVALID_TOKEN                                                      : return "The token representing the data is invalid";
    case ERROR_DEVICE_FEATURE_NOT_SUPPORTED                                       : return "The device does not support the command feature";
    case ERROR_MR_MID_NOT_FOUND                                                   : return "The system cannot find message text for message number 0x%%1 in the message file for %%2";
    case ERROR_SCOPE_NOT_FOUND                                                    : return "The scope specified was not found";
    case ERROR_UNDEFINED_SCOPE                                                    : return "The Central Access Policy specified is not defined on the target machine";
    case ERROR_INVALID_CAP                                                        : return "The Central Access Policy obtained from Active Directory is invalid";
    case ERROR_DEVICE_UNREACHABLE                                                 : return "The device is unreachable";
    case ERROR_DEVICE_NO_RESOURCES                                                : return "The target device has insufficient resources to complete the operation";
    case ERROR_DATA_CHECKSUM_ERROR                                                : return "A data integrity checksum error occurred. Data in the file stream is corrupt";
    case ERROR_INTERMIXED_KERNEL_EA_OPERATION                                     : return "An attempt was made to modify both a KERNEL and normal Extended Attribute (EA) in the same operation";
    case ERROR_FILE_LEVEL_TRIM_NOT_SUPPORTED                                      : return "Device does not support file-level TRIM";
    case ERROR_OFFSET_ALIGNMENT_VIOLATION                                         : return "The command specified a data offset that does not align to the device's granularity/alignment";
    case ERROR_INVALID_FIELD_IN_PARAMETER_LIST                                    : return "The command specified an invalid field in its parameter list";
    case ERROR_OPERATION_IN_PROGRESS                                              : return "An operation is currently in progress with the device";
    case ERROR_BAD_DEVICE_PATH                                                    : return "An attempt was made to send down the command via an invalid path to the target device";
    case ERROR_TOO_MANY_DESCRIPTORS                                               : return "The command specified a number of descriptors that exceeded the maximum supported by the device";
    case ERROR_SCRUB_DATA_DISABLED                                                : return "Scrub is disabled on the specified file";
    case ERROR_NOT_REDUNDANT_STORAGE                                              : return "The storage device does not provide redundancy";
    case ERROR_RESIDENT_FILE_NOT_SUPPORTED                                        : return "An operation is not supported on a resident file";
    case ERROR_COMPRESSED_FILE_NOT_SUPPORTED                                      : return "An operation is not supported on a compressed file";
    case ERROR_DIRECTORY_NOT_SUPPORTED                                            : return "An operation is not supported on a directory";
    case ERROR_NOT_READ_FROM_COPY                                                 : return "The specified copy of the requested data could not be read";
    case ERROR_FT_WRITE_FAILURE                                                   : return "The specified data could not be written to any of the copies";
    case ERROR_FT_DI_SCAN_REQUIRED                                                : return "One or more copies of data on this device may be out of sync. No writes may be performed until a data integrity scan is completed";
    case ERROR_INVALID_KERNEL_INFO_VERSION                                        : return "The supplied kernel information version is invalid";
    case ERROR_INVALID_PEP_INFO_VERSION                                           : return "The supplied PEP information version is invalid";
    case ERROR_OBJECT_NOT_EXTERNALLY_BACKED                                       : return "This object is not externally backed by any provider";
    case ERROR_EXTERNAL_BACKING_PROVIDER_UNKNOWN                                  : return "The external backing provider is not recognized";
    case ERROR_COMPRESSION_NOT_BENEFICIAL                                         : return "Compressing this object would not save space";
    case ERROR_STORAGE_TOPOLOGY_ID_MISMATCH                                       : return "The request failed due to a storage topology ID mismatch";
    case ERROR_BLOCKED_BY_PARENTAL_CONTROLS                                       : return "The operation was blocked by parental controls";
    case ERROR_BLOCK_TOO_MANY_REFERENCES                                          : return "A file system block being referenced has already reached the maximum reference count and can't be referenced any further";
    case ERROR_MARKED_TO_DISALLOW_WRITES                                          : return "The requested operation failed because the file stream is marked to disallow writes";
    case ERROR_ENCLAVE_FAILURE                                                    : return "The requested operation failed with an architecture-specific failure code";
    case ERROR_FAIL_NOACTION_REBOOT                                               : return "No action was taken as a system reboot is required";
    case ERROR_FAIL_SHUTDOWN                                                      : return "The shutdown operation failed";
    case ERROR_FAIL_RESTART                                                       : return "The restart operation failed";
    case ERROR_MAX_SESSIONS_REACHED                                               : return "The maximum number of sessions has been reached";
    case ERROR_NETWORK_ACCESS_DENIED_EDP                                          : return "Windows Information Protection policy does not allow access to this network resource";
    case ERROR_DEVICE_HINT_NAME_BUFFER_TOO_SMALL                                  : return "The device hint name buffer is too small to receive the remaining name";
    case ERROR_EDP_POLICY_DENIES_OPERATION                                        : return "The requested operation was blocked by Windows Information Protection policy. For more information, contact your system administrator";
    case ERROR_EDP_DPL_POLICY_CANT_BE_SATISFIED                                   : return "The requested operation cannot be performed because hardware or software configuration of the device does not comply with Windows Information Protection under Lock policy. Please, verify that user PIN has been created. For more information, contact your system administrator";
    case ERROR_CLOUD_FILE_SYNC_ROOT_METADATA_CORRUPT                              : return "The cloud sync root metadata is corrupted";
    case ERROR_DEVICE_IN_MAINTENANCE                                              : return "The device is in maintenance mode";
    case ERROR_NOT_SUPPORTED_ON_DAX                                               : return "This operation is not supported on a DAX volume";
    case ERROR_DAX_MAPPING_EXISTS                                                 : return "The volume has active DAX mappings";
    case ERROR_CLOUD_FILE_PROVIDER_NOT_RUNNING                                    : return "The cloud file provider is not running";
    case ERROR_CLOUD_FILE_METADATA_CORRUPT                                        : return "The cloud file metadata is corrupt and unreadable";
    case ERROR_CLOUD_FILE_METADATA_TOO_LARGE                                      : return "The cloud file metadata is too large";
    case ERROR_CLOUD_FILE_PROPERTY_BLOB_TOO_LARGE                                 : return "The cloud file property is too large";
    case ERROR_CLOUD_FILE_PROPERTY_BLOB_CHECKSUM_MISMATCH                         : return "The cloud file property is possibly corrupt. The on-disk checksum does not match the computed checksum";
    case ERROR_CHILD_PROCESS_BLOCKED                                              : return "The process creation has been blocked";
    case ERROR_STORAGE_LOST_DATA_PERSISTENCE                                      : return "The storage device has lost data or persistence";
    case ERROR_FILE_SYSTEM_VIRTUALIZATION_UNAVAILABLE                             : return "The provider that supports file system virtualization is temporarily unavailable";
    case ERROR_FILE_SYSTEM_VIRTUALIZATION_METADATA_CORRUPT                        : return "The metadata for file system virtualization is corrupt and unreadable";
    case ERROR_FILE_SYSTEM_VIRTUALIZATION_BUSY                                    : return "The provider that supports file system virtualization is too busy to complete this operation";
    case ERROR_FILE_SYSTEM_VIRTUALIZATION_PROVIDER_UNKNOWN                        : return "The provider that supports file system virtualization is unknown";
    case ERROR_GDI_HANDLE_LEAK                                                    : return "GDI handles were potentially leaked by the application";
    case ERROR_CLOUD_FILE_TOO_MANY_PROPERTY_BLOBS                                 : return "The maximum number of cloud file properties has been reached";
    case ERROR_CLOUD_FILE_PROPERTY_VERSION_NOT_SUPPORTED                          : return "The version of the cloud file property store is not supported";
    case ERROR_NOT_A_CLOUD_FILE                                                   : return "The file is not a cloud file";
    case ERROR_CLOUD_FILE_NOT_IN_SYNC                                             : return "The file is not in sync with the cloud";
    case ERROR_CLOUD_FILE_ALREADY_CONNECTED                                       : return "The cloud sync root is already connected with another cloud sync engine";
    case ERROR_CLOUD_FILE_NOT_SUPPORTED                                           : return "The operation is not supported by the cloud sync engine";
    case ERROR_CLOUD_FILE_INVALID_REQUEST                                         : return "The cloud operation is invalid";
    case ERROR_CLOUD_FILE_READ_ONLY_VOLUME                                        : return "The cloud operation is not supported on a read-only volume";
    case ERROR_CLOUD_FILE_CONNECTED_PROVIDER_ONLY                                 : return "The operation is reserved for a connected cloud sync engine";
    case ERROR_CLOUD_FILE_VALIDATION_FAILED                                       : return "The cloud sync engine failed to validate the downloaded data";
    case ERROR_SMB1_NOT_AVAILABLE                                                 : return "You can't connect to the file share because it's not secure. This share requires the obsolete SMB1 protocol, which is unsafe and could expose your system to attack";
    case ERROR_FILE_SYSTEM_VIRTUALIZATION_INVALID_OPERATION                       : return "The virtualization operation is not allowed on the file in its current state";
    case ERROR_CLOUD_FILE_AUTHENTICATION_FAILED                                   : return "The cloud sync engine failed user authentication";
    case ERROR_CLOUD_FILE_INSUFFICIENT_RESOURCES                                  : return "The cloud sync engine failed to perform the operation due to low system resources";
    case ERROR_CLOUD_FILE_NETWORK_UNAVAILABLE                                     : return "The cloud sync engine failed to perform the operation due to network being unavailable";
    case ERROR_CLOUD_FILE_UNSUCCESSFUL                                            : return "The cloud operation was unsuccessful";
    case ERROR_CLOUD_FILE_NOT_UNDER_SYNC_ROOT                                     : return "The operation is only supported on files under a cloud sync root";
    case ERROR_CLOUD_FILE_IN_USE                                                  : return "The operation cannot be performed on cloud files in use";
    case ERROR_CLOUD_FILE_PINNED                                                  : return "The operation cannot be performed on pinned cloud files";
    case ERROR_CLOUD_FILE_REQUEST_ABORTED                                         : return "The cloud operation was aborted";
    case ERROR_CLOUD_FILE_PROPERTY_CORRUPT                                        : return "The cloud file's property store is corrupt";
    case ERROR_CLOUD_FILE_ACCESS_DENIED                                           : return "Access to the cloud file is denied";
    case ERROR_CLOUD_FILE_INCOMPATIBLE_HARDLINKS                                  : return "The cloud operation cannot be performed on a file with incompatible hardlinks";
    case ERROR_CLOUD_FILE_PROPERTY_LOCK_CONFLICT                                  : return "The operation failed due to a conflicting cloud file property lock";
    case ERROR_CLOUD_FILE_REQUEST_CANCELED                                        : return "The cloud operation was canceled by user";
    case ERROR_EXTERNAL_SYSKEY_NOT_SUPPORTED                                      : return "An externally encrypted syskey has been configured, but the system no longer supports this feature.  Please see https://go.microsoft.com/fwlink/?linkid=851152 for more information";
    case ERROR_THREAD_MODE_ALREADY_BACKGROUND                                     : return "The thread is already in background processing mode";
    case ERROR_THREAD_MODE_NOT_BACKGROUND                                         : return "The thread is not in background processing mode";
    case ERROR_PROCESS_MODE_ALREADY_BACKGROUND                                    : return "The process is already in background processing mode";
    case ERROR_PROCESS_MODE_NOT_BACKGROUND                                        : return "The process is not in background processing mode";
    case ERROR_CAPAUTHZ_NOT_DEVUNLOCKED                                           : return "Neither developer unlocked mode nor side loading mode is enabled on the device";
    case ERROR_CAPAUTHZ_CHANGE_TYPE                                               : return "Can not change application type during upgrade or re-provision";
    case ERROR_CAPAUTHZ_NOT_PROVISIONED                                           : return "The application has not been provisioned";
    case ERROR_CAPAUTHZ_NOT_AUTHORIZED                                            : return "The requested capability can not be authorized for this application";
    case ERROR_CAPAUTHZ_NO_POLICY                                                 : return "There is no capability authorization policy on the device";
    case ERROR_CAPAUTHZ_DB_CORRUPTED                                              : return "The capability authorization database has been corrupted";
    case ERROR_CAPAUTHZ_SCCD_INVALID_CATALOG                                      : return "The custom capability's SCCD has an invalid catalog";
    case ERROR_CAPAUTHZ_SCCD_NO_AUTH_ENTITY                                       : return "There is no matching authorized in the SCCD";
    case ERROR_CAPAUTHZ_SCCD_PARSE_ERROR                                          : return "The custom capability's SCCD failed to parse";
    case ERROR_CAPAUTHZ_SCCD_DEV_MODE_REQUIRED                                    : return "The custom capability's SCCD requires developer mode";
    case ERROR_CAPAUTHZ_SCCD_NO_CAPABILITY_MATCH                                  : return "There not all declared custom capabilities are found in the SCCD";
    case ERROR_PNP_QUERY_REMOVE_DEVICE_TIMEOUT                                    : return "The operation timed out waiting for this device to complete a PnP query-remove request due to a potential hang in its device stack. The system may need to be rebooted to complete the request";
    case ERROR_PNP_QUERY_REMOVE_RELATED_DEVICE_TIMEOUT                            : return "The operation timed out waiting for this device to complete a PnP query-remove request due to a potential hang in the device stack of a related device. The system may need to be rebooted to complete the operation";
    case ERROR_PNP_QUERY_REMOVE_UNRELATED_DEVICE_TIMEOUT                          : return "The operation timed out waiting for this device to complete a PnP query-remove request due to a potential hang in the device stack of an unrelated device. The system may need to be rebooted to complete the operation";
    case ERROR_DEVICE_HARDWARE_ERROR                                              : return "The request failed due to a fatal device hardware error";
    case ERROR_INVALID_ADDRESS                                                    : return "Attempt to access invalid address";
    case ERROR_VRF_CFG_ENABLED                                                    : return "Driver Verifier Volatile settings cannot be set when CFG is enabled";
    case ERROR_PARTITION_TERMINATING                                              : return "An attempt was made to access a partition that has begun termination";
    case ERROR_USER_PROFILE_LOAD                                                  : return "User profile cannot be loaded";
    case ERROR_ARITHMETIC_OVERFLOW                                                : return "Arithmetic result exceeded 32 bits";
    case ERROR_PIPE_CONNECTED                                                     : return "There is a process on other end of the pipe";
    case ERROR_PIPE_LISTENING                                                     : return "Waiting for a process to open the other end of the pipe";
    case ERROR_VERIFIER_STOP                                                      : return "Application verifier has found an error in the current process";
    case ERROR_ABIOS_ERROR                                                        : return "An error occurred in the ABIOS subsystem";
    case ERROR_WX86_WARNING                                                       : return "A warning occurred in the WX86 subsystem";
    case ERROR_WX86_ERROR                                                         : return "An error occurred in the WX86 subsystem";
    case ERROR_TIMER_NOT_CANCELED                                                 : return "An attempt was made to cancel or set a timer that has an associated APC and the subject thread is not the thread that originally set the timer with an associated APC routine";
    case ERROR_UNWIND                                                             : return "Unwind exception code";
    case ERROR_BAD_STACK                                                          : return "An invalid or unaligned stack was encountered during an unwind operation";
    case ERROR_INVALID_UNWIND_TARGET                                              : return "An invalid unwind target was encountered during an unwind operation";
    case ERROR_INVALID_PORT_ATTRIBUTES                                            : return "Invalid Object Attributes specified to NtCreatePort or invalid Port Attributes specified to NtConnectPort";
    case ERROR_PORT_MESSAGE_TOO_LONG                                              : return "Length of message passed to NtRequestPort or NtRequestWaitReplyPort was longer than the maximum message allowed by the port";
    case ERROR_INVALID_QUOTA_LOWER                                                : return "An attempt was made to lower a quota limit below the current usage";
    case ERROR_DEVICE_ALREADY_ATTACHED                                            : return "An attempt was made to attach to a device that was already attached to another device";
    case ERROR_INSTRUCTION_MISALIGNMENT                                           : return "An attempt was made to execute an instruction at an unaligned address and the host system does not support unaligned instruction references";
    case ERROR_PROFILING_NOT_STARTED                                              : return "Profiling not started";
    case ERROR_PROFILING_NOT_STOPPED                                              : return "Profiling not stopped";
    case ERROR_COULD_NOT_INTERPRET                                                : return "The passed ACL did not contain the minimum required information";
    case ERROR_PROFILING_AT_LIMIT                                                 : return "The number of active profiling objects is at the maximum and no more may be started";
    case ERROR_CANT_WAIT                                                          : return "Used to indicate that an operation cannot continue without blocking for I/O";
    case ERROR_CANT_TERMINATE_SELF                                                : return "Indicates that a thread attempted to terminate itself by default (called NtTerminateThread with NULL) and it was the last thread in the current process";
    case ERROR_UNEXPECTED_MM_CREATE_ERR                                           : return "If an MM error is returned which is not defined in the standard FsRtl filter, it is converted to one of the following errors which is guaranteed to be in the filter";
    case ERROR_UNEXPECTED_MM_MAP_ERROR                                            : return "If an MM error is returned which is not defined in the standard FsRtl filter, it is converted to one of the following errors which is guaranteed to be in the filter";
    case ERROR_UNEXPECTED_MM_EXTEND_ERR                                           : return "If an MM error is returned which is not defined in the standard FsRtl filter, it is converted to one of the following errors which is guaranteed to be in the filter";
    case ERROR_BAD_FUNCTION_TABLE                                                 : return "A malformed function table was encountered during an unwind operation";
    case ERROR_NO_GUID_TRANSLATION                                                : return "Indicates that an attempt was made to assign protection to a file system file or directory and one of the SIDs in the security descriptor could not be translated into a GUID that could be stored by the file system";
    case ERROR_INVALID_LDT_SIZE                                                   : return "Indicates that an attempt was made to grow an LDT by setting its size, or that the size was not an even number of selectors";
    case ERROR_INVALID_LDT_OFFSET                                                 : return "Indicates that the starting value for the LDT information was not an integral multiple of the selector size";
    case ERROR_INVALID_LDT_DESCRIPTOR                                             : return "Indicates that the user supplied an invalid descriptor when trying to set up Ldt descriptors";
    case ERROR_TOO_MANY_THREADS                                                   : return "Indicates a process has too many threads to perform the requested action. For example, assignment of a primary token may only be performed when a process has zero or one threads";
    case ERROR_THREAD_NOT_IN_PROCESS                                              : return "An attempt was made to operate on a thread within a specific process, but the thread specified is not in the process specified";
    case ERROR_PAGEFILE_QUOTA_EXCEEDED                                            : return "Page file quota was exceeded";
    case ERROR_LOGON_SERVER_CONFLICT                                              : return "The Netlogon service cannot start because another Netlogon service running in the domain conflicts with the specified role";
    case ERROR_SYNCHRONIZATION_REQUIRED                                           : return "The SAM database on a Windows Server is significantly out of synchronization with the copy on the Domain Controller. A complete synchronization is required";
    case ERROR_NET_OPEN_FAILED                                                    : return "The NtCreateFile API failed. This error should never be returned to an application, it is a place holder for the Windows Lan Manager Redirector to use in its internal error mapping routines";
    case ERROR_IO_PRIVILEGE_FAILED                                                : return "The I/O permissions for the process could not be changed";
    case ERROR_CONTROL_C_EXIT                                                     : return "The application terminated as a result of a CTRL+C";
    case ERROR_MISSING_SYSTEMFILE                                                 : return "The required system file %%hs is bad or missing";
    case ERROR_UNHANDLED_EXCEPTION                                                : return "The exception %%s (0x%%08lx) occurred in the application at location 0x%%08lx";
    case ERROR_APP_INIT_FAILURE                                                   : return "The application was unable to start correctly (0x%%lx). Click OK to close the application";
    case ERROR_PAGEFILE_CREATE_FAILED                                             : return "The creation of the paging file %%hs failed (%%lx). The requested size was %%ld";
    case ERROR_INVALID_IMAGE_HASH                                                 : return "Windows cannot verify the digital signature for this file. A recent hardware or software change might have installed a file that is signed incorrectly or damaged, or that might be malicious software from an unknown source";
    case ERROR_NO_PAGEFILE                                                        : return "No paging file was specified in the system configuration";
    case ERROR_ILLEGAL_FLOAT_CONTEXT                                              : return "A real-mode application issued a floating-point instruction and floating-point hardware is not present";
    case ERROR_NO_EVENT_PAIR                                                      : return "An event pair synchronization operation was performed using the thread specific client/server event pair object, but no event pair object was associated with the thread";
    case ERROR_DOMAIN_CTRLR_CONFIG_ERROR                                          : return "A Windows Server has an incorrect configuration";
    case ERROR_ILLEGAL_CHARACTER                                                  : return "An illegal character was encountered. For a multi-byte character set this includes a lead byte without a succeeding trail byte. For the Unicode character set this includes the characters 0xFFFF and 0xFFFE";
    case ERROR_UNDEFINED_CHARACTER                                                : return "The Unicode character is not defined in the Unicode character set installed on the system";
    case ERROR_FLOPPY_VOLUME                                                      : return "The paging file cannot be created on a floppy diskette";
    case ERROR_BIOS_FAILED_TO_CONNECT_INTERRUPT                                   : return "The system BIOS failed to connect a system interrupt to the device or bus for which the device is connected";
    case ERROR_BACKUP_CONTROLLER                                                  : return "This operation is only allowed for the Primary Domain Controller of the domain";
    case ERROR_MUTANT_LIMIT_EXCEEDED                                              : return "An attempt was made to acquire a mutant such that its maximum count would have been exceeded";
    case ERROR_FS_DRIVER_REQUIRED                                                 : return "A volume has been accessed for which a file system driver is required that has not yet been loaded";
    case ERROR_CANNOT_LOAD_REGISTRY_FILE                                          : return "The registry cannot load the hive (file):";
    case ERROR_DEBUG_ATTACH_FAILED                                                : return "An unexpected failure occurred while processing a DebugActiveProcess API request. You may choose OK to terminate the process, or Cancel to ignore the error";
    case ERROR_SYSTEM_PROCESS_TERMINATED                                          : return "The %%hs system process terminated unexpectedly with a status of 0x%%08x (0x%%08x 0x%%08x)";
    case ERROR_DATA_NOT_ACCEPTED                                                  : return "The TDI client could not handle the data received during an indication";
    case ERROR_VDM_HARD_ERROR                                                     : return "NTVDM encountered a hard error";
    case ERROR_DRIVER_CANCEL_TIMEOUT                                              : return "The driver %%hs failed to complete a cancelled I/O request in the allotted time";
    case ERROR_REPLY_MESSAGE_MISMATCH                                             : return "An attempt was made to reply to an LPC message, but the thread specified by the client ID in the message was not waiting on that message";
    case ERROR_LOST_WRITEBEHIND_DATA                                              : return "Windows was unable to save all the data for the file %%hs. The data has been lost";
    case ERROR_CLIENT_SERVER_PARAMETERS_INVALID                                   : return "The parameter(s) passed to the server in the client/server shared memory window were invalid. Too much data may have been put in the shared memory window";
    case ERROR_NOT_TINY_STREAM                                                    : return "The stream is not a tiny stream";
    case ERROR_STACK_OVERFLOW_READ                                                : return "The request must be handled by the stack overflow code";
    case ERROR_CONVERT_TO_LARGE                                                   : return "Internal OFS status codes indicating how an allocation operation is handled. Either it is retried after the containing onode is moved or the extent stream is converted to a large stream";
    case ERROR_FOUND_OUT_OF_SCOPE                                                 : return "The attempt to find the object found an object matching by ID on the volume but it is out of the scope of the handle used for the operation";
    case ERROR_ALLOCATE_BUCKET                                                    : return "The bucket array must be grown. Retry transaction after doing so";
    case ERROR_MARSHALL_OVERFLOW                                                  : return "The user/kernel marshalling buffer has overflowed";
    case ERROR_INVALID_VARIANT                                                    : return "The supplied variant structure contains invalid data";
    case ERROR_BAD_COMPRESSION_BUFFER                                             : return "The specified buffer contains ill-formed data";
    case ERROR_AUDIT_FAILED                                                       : return "An attempt to generate a security audit failed";
    case ERROR_TIMER_RESOLUTION_NOT_SET                                           : return "The timer resolution was not previously set by the current process";
    case ERROR_INSUFFICIENT_LOGON_INFO                                            : return "There is insufficient account information to log you on";
    case ERROR_BAD_DLL_ENTRYPOINT                                                 : return "The dynamic link library %%hs is not written correctly. The stack pointer has been left in an inconsistent state";
    case ERROR_BAD_SERVICE_ENTRYPOINT                                             : return "The %%hs service is not written correctly. The stack pointer has been left in an inconsistent state";
    case ERROR_IP_ADDRESS_CONFLICT1                                               : return "There is an IP address conflict with another system on the network";
    case ERROR_IP_ADDRESS_CONFLICT2                                               : return "There is an IP address conflict with another system on the network";
    case ERROR_REGISTRY_QUOTA_LIMIT                                               : return "The system has reached the maximum size allowed for the system part of the registry. Additional storage requests will be ignored";
    case ERROR_NO_CALLBACK_ACTIVE                                                 : return "A callback return system service cannot be executed when no callback is active";
    case ERROR_PWD_TOO_SHORT                                                      : return "The password provided is too short to meet the policy of your user account";
    case ERROR_PWD_TOO_RECENT                                                     : return "The policy of your user account does not allow you to change passwords too frequently";
    case ERROR_PWD_HISTORY_CONFLICT                                               : return "You have attempted to change your password to one that you have used in the past";
    case ERROR_UNSUPPORTED_COMPRESSION                                            : return "The specified compression format is unsupported";
    case ERROR_INVALID_HW_PROFILE                                                 : return "The specified hardware profile configuration is invalid";
    case ERROR_INVALID_PLUGPLAY_DEVICE_PATH                                       : return "The specified Plug and Play registry device path is invalid";
    case ERROR_QUOTA_LIST_INCONSISTENT                                            : return "The specified quota list is internally inconsistent with its descriptor";
    case ERROR_EVALUATION_EXPIRATION                                              : return "The evaluation period for this installation of Windows has expired. This system will shutdown in 1 hour. To restore access to this installation of Windows, please upgrade this installation using a licensed distribution of this product";
    case ERROR_ILLEGAL_DLL_RELOCATION                                             : return "The system DLL %%hs was relocated in memory. The application will not run properly";
    case ERROR_DLL_INIT_FAILED_LOGOFF                                             : return "The application failed to initialize because the window station is shutting down";
    case ERROR_VALIDATE_CONTINUE                                                  : return "The validation process needs to continue on to the next step";
    case ERROR_NO_MORE_MATCHES                                                    : return "There are no more matches for the current index enumeration";
    case ERROR_RANGE_LIST_CONFLICT                                                : return "The range could not be added to the range list because of a conflict";
    case ERROR_SERVER_SID_MISMATCH                                                : return "The server process is running under a SID different than that required by client";
    case ERROR_CANT_ENABLE_DENY_ONLY                                              : return "A group marked use for deny only cannot be enabled";
    case ERROR_FLOAT_MULTIPLE_FAULTS                                              : return "Multiple floating point faults";
    case ERROR_FLOAT_MULTIPLE_TRAPS                                               : return "Multiple floating point traps";
    case ERROR_NOINTERFACE                                                        : return "The requested interface is not supported";
    case ERROR_DRIVER_FAILED_SLEEP                                                : return "The driver %%hs does not support standby mode. Updating this driver may allow the system to go to standby mode";
    case ERROR_CORRUPT_SYSTEM_FILE                                                : return "The system file %%1 has become corrupt and has been replaced";
    case ERROR_COMMITMENT_MINIMUM                                                 : return "Your system is low on virtual memory. Windows is increasing the size of your virtual memory paging file";
    case ERROR_PNP_RESTART_ENUMERATION                                            : return "A device was removed so enumeration must be restarted";
    case ERROR_SYSTEM_IMAGE_BAD_SIGNATURE                                         : return "The system image %%s is not properly signed";
    case ERROR_PNP_REBOOT_REQUIRED                                                : return "Device will not start without a reboot";
    case ERROR_INSUFFICIENT_POWER                                                 : return "There is not enough power to complete the requested operation";
    case ERROR_MULTIPLE_FAULT_VIOLATION                                           : return "ERROR_MULTIPLE_FAULT_VIOLATION";
    case ERROR_SYSTEM_SHUTDOWN                                                    : return "The system is in the process of shutting down";
    case ERROR_PORT_NOT_SET                                                       : return "An attempt to remove a processes DebugPort was made, but a port was not already associated with the process";
    case ERROR_DS_VERSION_CHECK_FAILURE                                           : return "This version of Windows is not compatible with the behavior version of directory forest, domain or domain controller";
    case ERROR_RANGE_NOT_FOUND                                                    : return "The specified range could not be found in the range list";
    case ERROR_NOT_SAFE_MODE_DRIVER                                               : return "The driver was not loaded because the system is booting into safe mode";
    case ERROR_FAILED_DRIVER_ENTRY                                                : return "The driver was not loaded because it failed its initialization call";
    case ERROR_DEVICE_ENUMERATION_ERROR                                           : return "The \"%%hs\" encountered an error while applying power or reading the device configuration";
    case ERROR_MOUNT_POINT_NOT_RESOLVED                                           : return "The create operation failed because the name contained at least one mount point which resolves to a volume to which the specified device object is not attached";
    case ERROR_INVALID_DEVICE_OBJECT_PARAMETER                                    : return "The device object parameter is either not a valid device object or is not attached to the volume specified by the file name";
    case ERROR_MCA_OCCURED                                                        : return "A Machine Check Error has occurred. Please check the system eventlog for additional information";
    case ERROR_DRIVER_DATABASE_ERROR                                              : return "There was error [%%2] processing the driver database";
    case ERROR_SYSTEM_HIVE_TOO_LARGE                                              : return "System hive size has exceeded its limit";
    case ERROR_DRIVER_FAILED_PRIOR_UNLOAD                                         : return "The driver could not be loaded because a previous version of the driver is still in memory";
    case ERROR_VOLSNAP_PREPARE_HIBERNATE                                          : return "Please wait while the Volume Shadow Copy Service prepares volume %%hs for hibernation";
    case ERROR_HIBERNATION_FAILURE                                                : return "The system has failed to hibernate (The error code is %%hs). Hibernation will be disabled until the system is restarted";
    case ERROR_PWD_TOO_LONG                                                       : return "The password provided is too long to meet the policy of your user account";
    case ERROR_FILE_SYSTEM_LIMITATION                                             : return "The requested operation could not be completed due to a file system limitation";
    case ERROR_ASSERTION_FAILURE                                                  : return "An assertion failure has occurred";
    case ERROR_ACPI_ERROR                                                         : return "An error occurred in the ACPI subsystem";
    case ERROR_WOW_ASSERTION                                                      : return "WOW Assertion Error";
    case ERROR_PNP_BAD_MPS_TABLE                                                  : return "A device is missing in the system BIOS MPS table. This device will not be used";
    case ERROR_PNP_TRANSLATION_FAILED                                             : return "A translator failed to translate resources";
    case ERROR_PNP_IRQ_TRANSLATION_FAILED                                         : return "A IRQ translator failed to translate resources";
    case ERROR_PNP_INVALID_ID                                                     : return "Driver %%2 returned invalid ID for a child device (%%3)";
    case ERROR_WAKE_SYSTEM_DEBUGGER                                               : return "the system debugger was awakened by an interrupt";
    case ERROR_HANDLES_CLOSED                                                     : return "Handles to objects have been automatically closed as a result of the requested operation";
    case ERROR_EXTRANEOUS_INFORMATION                                             : return "The specified access control list (ACL) contained more information than was expected";
    case ERROR_RXACT_COMMIT_NECESSARY                                             : return "This warning level status indicates that the transaction state already exists for the registry sub-tree, but that a transaction commit was previously aborted";
    case ERROR_MEDIA_CHECK                                                        : return "The media may have changed";
    case ERROR_GUID_SUBSTITUTION_MADE                                             : return "During the translation of a global identifier (GUID) to a Windows security ID (SID), no administratively-defined GUID prefix was found";
    case ERROR_STOPPED_ON_SYMLINK                                                 : return "The create operation stopped after reaching a symbolic link";
    case ERROR_LONGJUMP                                                           : return "A long jump has been executed";
    case ERROR_PLUGPLAY_QUERY_VETOED                                              : return "The Plug and Play query operation was not successful";
    case ERROR_UNWIND_CONSOLIDATE                                                 : return "A frame consolidation has been executed";
    case ERROR_REGISTRY_HIVE_RECOVERED                                            : return "Registry hive (file):";
    case ERROR_DLL_MIGHT_BE_INSECURE                                              : return "The application is attempting to run executable code from the module %%hs. This may be insecure. An alternative, %%hs, is available. Should the application use the secure module %%hs?";
    case ERROR_DLL_MIGHT_BE_INCOMPATIBLE                                          : return "The application is loading executable code from the module %%hs. This is secure, but may be incompatible with previous releases of the operating system. An alternative, %%hs, is available. Should the application use the secure module %%hs?";
    case ERROR_DBG_EXCEPTION_NOT_HANDLED                                          : return "Debugger did not handle the exception";
    case ERROR_DBG_REPLY_LATER                                                    : return "Debugger will reply later";
    case ERROR_DBG_UNABLE_TO_PROVIDE_HANDLE                                       : return "Debugger cannot provide handle";
    case ERROR_DBG_TERMINATE_THREAD                                               : return "Debugger terminated thread";
    case ERROR_DBG_TERMINATE_PROCESS                                              : return "Debugger terminated process";
    case ERROR_DBG_CONTROL_C                                                      : return "Debugger got control C";
    case ERROR_DBG_PRINTEXCEPTION_C                                               : return "Debugger printed exception on control C";
    case ERROR_DBG_RIPEXCEPTION                                                   : return "Debugger received RIP exception";
    case ERROR_DBG_CONTROL_BREAK                                                  : return "Debugger received control break";
    case ERROR_DBG_COMMAND_EXCEPTION                                              : return "Debugger command communication exception";
    case ERROR_OBJECT_NAME_EXISTS                                                 : return "An attempt was made to create an object and the object name already existed";
    case ERROR_THREAD_WAS_SUSPENDED                                               : return "A thread termination occurred while the thread was suspended. The thread was resumed, and termination proceeded";
    case ERROR_IMAGE_NOT_AT_BASE                                                  : return "An image file could not be mapped at the address specified in the image file. Local fixups must be performed on this image";
    case ERROR_RXACT_STATE_CREATED                                                : return "This informational level status indicates that a specified registry sub-tree transaction state did not yet exist and had to be created";
    case ERROR_SEGMENT_NOTIFICATION                                               : return "A virtual DOS machine (VDM) is loading, unloading, or moving an MS-DOS or Win16 program segment image";
    case ERROR_BAD_CURRENT_DIRECTORY                                              : return "The process cannot switch to the startup current directory %%hs";
    case ERROR_FT_READ_RECOVERY_FROM_BACKUP                                       : return "To satisfy a read request, the NT fault-tolerant file system successfully read the requested data from a redundant copy";
    case ERROR_FT_WRITE_RECOVERY                                                  : return "To satisfy a write request, the NT fault-tolerant file system successfully wrote a redundant copy of the information";
    case ERROR_IMAGE_MACHINE_TYPE_MISMATCH                                        : return "The image file %%hs is valid, but is for a machine type other than the current machine. Select OK to continue, or CANCEL to fail the DLL load";
    case ERROR_RECEIVE_PARTIAL                                                    : return "The network transport returned partial data to its client. The remaining data will be sent later";
    case ERROR_RECEIVE_EXPEDITED                                                  : return "The network transport returned data to its client that was marked as expedited by the remote system";
    case ERROR_RECEIVE_PARTIAL_EXPEDITED                                          : return "The network transport returned partial data to its client and this data was marked as expedited by the remote system. The remaining data will be sent later";
    case ERROR_EVENT_DONE                                                         : return "The TDI indication has completed successfully";
    case ERROR_EVENT_PENDING                                                      : return "The TDI indication has entered the pending state";
    case ERROR_CHECKING_FILE_SYSTEM                                               : return "Checking file system on %%wZ";
    case ERROR_FATAL_APP_EXIT                                                     : return "%hs";
    case ERROR_PREDEFINED_HANDLE                                                  : return "The specified registry key is referenced by a predefined handle";
    case ERROR_WAS_UNLOCKED                                                       : return "The page protection of a locked page was changed to 'No Access' and the page was unlocked from memory and from the process";
    case ERROR_SERVICE_NOTIFICATION                                               : return "%hs";
    case ERROR_WAS_LOCKED                                                         : return "One of the pages to lock was already locked";
    case ERROR_LOG_HARD_ERROR                                                     : return "Application popup: %%1 : %%2";
    case ERROR_ALREADY_WIN32                                                      : return "ERROR_ALREADY_WIN32";
    case ERROR_IMAGE_MACHINE_TYPE_MISMATCH_EXE                                    : return "The image file %%hs is valid, but is for a machine type other than the current machine";
    case ERROR_NO_YIELD_PERFORMED                                                 : return "A yield execution was performed and no thread was available to run";
    case ERROR_TIMER_RESUME_IGNORED                                               : return "The resumable flag to a timer API was ignored";
    case ERROR_ARBITRATION_UNHANDLED                                              : return "The arbiter has deferred arbitration of these resources to its parent";
    case ERROR_CARDBUS_NOT_SUPPORTED                                              : return "The inserted CardBus device cannot be started because of a configuration error on \"%%hs\"";
    case ERROR_MP_PROCESSOR_MISMATCH                                              : return "The CPUs in this multiprocessor system are not all the same revision level. To use all processors the operating system restricts itself to the features of the least capable processor in the system. Should problems occur with this system, contact the CPU manufacturer to see if this mix of processors is supported";
    case ERROR_HIBERNATED                                                         : return "The system was put into hibernation";
    case ERROR_RESUME_HIBERNATION                                                 : return "The system was resumed from hibernation";
    case ERROR_FIRMWARE_UPDATED                                                   : return "Windows has detected that the system firmware (BIOS) was updated [previous firmware date = %%2, current firmware date %%3]";
    case ERROR_DRIVERS_LEAKING_LOCKED_PAGES                                       : return "A device driver is leaking locked I/O pages causing system degradation. The system has automatically enabled tracking code in order to try and catch the culprit";
    case ERROR_WAKE_SYSTEM                                                        : return "The system has awoken";
    case ERROR_WAIT_1                                                             : return "ERROR_WAIT_1";
    case ERROR_WAIT_2                                                             : return "ERROR_WAIT_2";
    case ERROR_WAIT_3                                                             : return "ERROR_WAIT_3";
    case ERROR_WAIT_63                                                            : return "ERROR_WAIT_63";
    case ERROR_ABANDONED_WAIT_0                                                   : return "ERROR_ABANDONED_WAIT_0";
    case ERROR_ABANDONED_WAIT_63                                                  : return "ERROR_ABANDONED_WAIT_63";
    case ERROR_USER_APC                                                           : return "ERROR_USER_APC";
    case ERROR_KERNEL_APC                                                         : return "ERROR_KERNEL_APC";
    case ERROR_ALERTED                                                            : return "ERROR_ALERTED";
    case ERROR_ELEVATION_REQUIRED                                                 : return "The requested operation requires elevation";
    case ERROR_REPARSE                                                            : return "A reparse should be performed by the Object Manager since the name of the file resulted in a symbolic link";
    case ERROR_OPLOCK_BREAK_IN_PROGRESS                                           : return "An open/create operation completed while an oplock break is underway";
    case ERROR_VOLUME_MOUNTED                                                     : return "A new volume has been mounted by a file system";
    case ERROR_RXACT_COMMITTED                                                    : return "This success level status indicates that the transaction state already exists for the registry sub-tree, but that a transaction commit was previously aborted";
    case ERROR_NOTIFY_CLEANUP                                                     : return "This indicates that a notify change request has been completed due to closing the handle which made the notify change request";
    case ERROR_PRIMARY_TRANSPORT_CONNECT_FAILED                                   : return "An attempt was made to connect to the remote server %%hs on the primary transport, but the connection failed";
    case ERROR_PAGE_FAULT_TRANSITION                                              : return "Page fault was a transition fault";
    case ERROR_PAGE_FAULT_DEMAND_ZERO                                             : return "Page fault was a demand zero fault";
    case ERROR_PAGE_FAULT_COPY_ON_WRITE                                           : return "Page fault was a demand zero fault";
    case ERROR_PAGE_FAULT_GUARD_PAGE                                              : return "Page fault was a demand zero fault";
    case ERROR_PAGE_FAULT_PAGING_FILE                                             : return "Page fault was satisfied by reading from a secondary storage device";
    case ERROR_CACHE_PAGE_LOCKED                                                  : return "Cached page was locked during operation";
    case ERROR_CRASH_DUMP                                                         : return "Crash dump exists in paging file";
    case ERROR_BUFFER_ALL_ZEROS                                                   : return "Specified buffer contains all zeros";
    case ERROR_REPARSE_OBJECT                                                     : return "A reparse should be performed by the Object Manager since the name of the file resulted in a symbolic link";
    case ERROR_RESOURCE_REQUIREMENTS_CHANGED                                      : return "The device has succeeded a query-stop and its resource requirements have changed";
    case ERROR_TRANSLATION_COMPLETE                                               : return "The translator has translated these resources into the global space and no further translations should be performed";
    case ERROR_NOTHING_TO_TERMINATE                                               : return "A process being terminated has no threads to terminate";
    case ERROR_PROCESS_NOT_IN_JOB                                                 : return "The specified process is not part of a job";
    case ERROR_PROCESS_IN_JOB                                                     : return "The specified process is part of a job";
    case ERROR_VOLSNAP_HIBERNATE_READY                                            : return "The system is now ready for hibernation";
    case ERROR_FSFILTER_OP_COMPLETED_SUCCESSFULLY                                 : return "A file system or file system filter driver has successfully completed an FsFilter operation";
    case ERROR_INTERRUPT_VECTOR_ALREADY_CONNECTED                                 : return "The specified interrupt vector was already connected";
    case ERROR_INTERRUPT_STILL_CONNECTED                                          : return "The specified interrupt vector is still connected";
    case ERROR_WAIT_FOR_OPLOCK                                                    : return "An operation is blocked waiting for an oplock";
    case ERROR_DBG_EXCEPTION_HANDLED                                              : return "Debugger handled exception";
    case ERROR_DBG_CONTINUE                                                       : return "Debugger continued";
    case ERROR_CALLBACK_POP_STACK                                                 : return "An exception occurred in a user mode callback and the kernel callback frame should be removed";
    case ERROR_COMPRESSION_DISABLED                                               : return "Compression is disabled for this volume";
    case ERROR_CANTFETCHBACKWARDS                                                 : return "The data provider cannot fetch backwards through a result set";
    case ERROR_CANTSCROLLBACKWARDS                                                : return "The data provider cannot scroll backwards through a result set";
    case ERROR_ROWSNOTRELEASED                                                    : return "The data provider requires that previously fetched data is released before asking for more data";
    case ERROR_BAD_ACCESSOR_FLAGS                                                 : return "The data provider was not able to interpret the flags set for a column binding in an accessor";
    case ERROR_ERRORS_ENCOUNTERED                                                 : return "One or more errors occurred while processing the request";
    case ERROR_NOT_CAPABLE                                                        : return "The implementation is not capable of performing the request";
    case ERROR_REQUEST_OUT_OF_SEQUENCE                                            : return "The client of a component requested an operation which is not valid given the state of the component instance";
    case ERROR_VERSION_PARSE_ERROR                                                : return "A version number could not be parsed";
    case ERROR_BADSTARTPOSITION                                                   : return "The iterator's start position is invalid";
    case ERROR_MEMORY_HARDWARE                                                    : return "The hardware has reported an uncorrectable memory error";
    case ERROR_DISK_REPAIR_DISABLED                                               : return "The attempted operation required self healing to be enabled";
    case ERROR_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE            : return "The Desktop heap encountered an error while allocating session memory. There is more information in the system event log";
    case ERROR_SYSTEM_POWERSTATE_TRANSITION                                       : return "The system power state is transitioning from %%2 to %%3";
    case ERROR_SYSTEM_POWERSTATE_COMPLEX_TRANSITION                               : return "The system power state is transitioning from %%2 to %%3 but could enter %%4";
    case ERROR_MCA_EXCEPTION                                                      : return "A thread is getting dispatched with MCA EXCEPTION because of MCA";
    case ERROR_ACCESS_AUDIT_BY_POLICY                                             : return "Access to %%1 is monitored by policy rule %%2";
    case ERROR_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY                              : return "Access to %%1 has been restricted by your Administrator by policy rule %%2";
    case ERROR_ABANDON_HIBERFILE                                                  : return "A valid hibernation file has been invalidated and should be abandoned";
    case ERROR_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED                         : return "Windows was unable to save all the data for the file %%hs; the data has been lost";
    case ERROR_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR                         : return "Windows was unable to save all the data for the file %%hs; the data has been lost";
    case ERROR_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR                             : return "Windows was unable to save all the data for the file %%hs; the data has been lost";
    case ERROR_BAD_MCFG_TABLE                                                     : return "The resources required for this device conflict with the MCFG table";
    case ERROR_DISK_REPAIR_REDIRECTED                                             : return "The volume repair could not be performed while it is online";
    case ERROR_DISK_REPAIR_UNSUCCESSFUL                                           : return "The volume repair was not successful";
    case ERROR_CORRUPT_LOG_OVERFULL                                               : return "One of the volume corruption logs is full. Further corruptions that may be detected won't be logged";
    case ERROR_CORRUPT_LOG_CORRUPTED                                              : return "One of the volume corruption logs is internally corrupted and needs to be recreated. The volume may contain undetected corruptions and must be scanned";
    case ERROR_CORRUPT_LOG_UNAVAILABLE                                            : return "One of the volume corruption logs is unavailable for being operated on";
    case ERROR_CORRUPT_LOG_DELETED_FULL                                           : return "One of the volume corruption logs was deleted while still having corruption records in them. The volume contains detected corruptions and must be scanned";
    case ERROR_CORRUPT_LOG_CLEARED                                                : return "One of the volume corruption logs was cleared by chkdsk and no longer contains real corruptions";
    case ERROR_ORPHAN_NAME_EXHAUSTED                                              : return "Orphaned files exist on the volume but could not be recovered because no more new names could be created in the recovery directory. Files must be moved from the recovery directory";
    case ERROR_OPLOCK_SWITCHED_TO_NEW_HANDLE                                      : return "The oplock that was associated with this handle is now associated with a different handle";
    case ERROR_CANNOT_GRANT_REQUESTED_OPLOCK                                      : return "An oplock of the requested level cannot be granted.  An oplock of a lower level may be available";
    case ERROR_CANNOT_BREAK_OPLOCK                                                : return "The operation did not complete successfully because it would cause an oplock to be broken. The caller has requested that existing oplocks not be broken";
    case ERROR_OPLOCK_HANDLE_CLOSED                                               : return "The handle with which this oplock was associated has been closed.  The oplock is now broken";
    case ERROR_NO_ACE_CONDITION                                                   : return "The specified access control entry (ACE) does not contain a condition";
    case ERROR_INVALID_ACE_CONDITION                                              : return "The specified access control entry (ACE) contains an invalid condition";
    case ERROR_FILE_HANDLE_REVOKED                                                : return "Access to the specified file handle has been revoked";
    case ERROR_IMAGE_AT_DIFFERENT_BASE                                            : return "An image file was mapped at a different address from the one specified in the image file but fixups will still be automatically performed on the image";
    case ERROR_ENCRYPTED_IO_NOT_POSSIBLE                                          : return "The read or write operation to an encrypted file could not be completed because the file has not been opened for data access";
    case ERROR_FILE_METADATA_OPTIMIZATION_IN_PROGRESS                             : return "File metadata optimization is already in progress";
    case ERROR_QUOTA_ACTIVITY                                                     : return "The requested operation failed due to quota operation is still in progress";
    case ERROR_HANDLE_REVOKED                                                     : return "Access to the specified handle has been revoked";
    case ERROR_CALLBACK_INVOKE_INLINE                                             : return "The callback function must be invoked inline";
    case ERROR_CPU_SET_INVALID                                                    : return "The specified CPU Set IDs are invalid";
    case ERROR_ENCLAVE_NOT_TERMINATED                                             : return "The specified enclave has not yet been terminated";
    case ERROR_EA_ACCESS_DENIED                                                   : return "Access to the extended attribute was denied";
    case ERROR_OPERATION_ABORTED                                                  : return "The I/O operation has been aborted because of either a thread exit or an application request";
    case ERROR_IO_INCOMPLETE                                                      : return "Overlapped I/O event is not in a signaled state";
    case ERROR_IO_PENDING                                                         : return "Overlapped I/O operation is in progress";
    case ERROR_NOACCESS                                                           : return "Invalid access to memory location";
    case ERROR_SWAPERROR                                                          : return "Error performing inpage operation";
    case ERROR_STACK_OVERFLOW                                                     : return "Recursion too deep; the stack overflowed";
    case ERROR_INVALID_MESSAGE                                                    : return "The window cannot act on the sent message";
    case ERROR_CAN_NOT_COMPLETE                                                   : return "Cannot complete this function";
    case ERROR_INVALID_FLAGS                                                      : return "Invalid flags";
    case ERROR_UNRECOGNIZED_VOLUME                                                : return "The volume does not contain a recognized file system";
    case ERROR_FILE_INVALID                                                       : return "The volume for a file has been externally altered so that the opened file is no longer valid";
    case ERROR_FULLSCREEN_MODE                                                    : return "The requested operation cannot be performed in full-screen mode";
    case ERROR_NO_TOKEN                                                           : return "An attempt was made to reference a token that does not exist";
    case ERROR_BADDB                                                              : return "The configuration registry database is corrupt";
    case ERROR_BADKEY                                                             : return "The configuration registry key is invalid";
    case ERROR_CANTOPEN                                                           : return "The configuration registry key could not be opened";
    case ERROR_CANTREAD                                                           : return "The configuration registry key could not be read";
    case ERROR_CANTWRITE                                                          : return "The configuration registry key could not be written";
    case ERROR_REGISTRY_RECOVERED                                                 : return "One of the files in the registry database had to be recovered by use of a log or alternate copy. The recovery was successful";
    case ERROR_REGISTRY_CORRUPT                                                   : return "The registry is corrupted. The structure of one of the files containing registry data is corrupted, or the system's memory image of the file is corrupted, or the file could not be recovered because the alternate copy or log was absent or corrupted";
    case ERROR_REGISTRY_IO_FAILED                                                 : return "An I/O operation initiated by the registry failed unrecoverably. The registry could not read in, or write out, or flush, one of the files that contain the system's image of the registry";
    case ERROR_NOT_REGISTRY_FILE                                                  : return "The system has attempted to load or restore a file into the registry, but the specified file is not in a registry file format";
    case ERROR_KEY_DELETED                                                        : return "Illegal operation attempted on a registry key that has been marked for deletion";
    case ERROR_NO_LOG_SPACE                                                       : return "System could not allocate the required space in a registry log";
    case ERROR_KEY_HAS_CHILDREN                                                   : return "Cannot create a symbolic link in a registry key that already has subkeys or values";
    case ERROR_CHILD_MUST_BE_VOLATILE                                             : return "Cannot create a stable subkey under a volatile parent key";
    case ERROR_NOTIFY_ENUM_DIR                                                    : return "A notify change request is being completed and the information is not being returned in the caller's buffer. The caller now needs to enumerate the files to find the changes";
    case ERROR_DEPENDENT_SERVICES_RUNNING                                         : return "A stop control has been sent to a service that other running services are dependent on";
    case ERROR_INVALID_SERVICE_CONTROL                                            : return "The requested control is not valid for this service";
    case ERROR_SERVICE_REQUEST_TIMEOUT                                            : return "The service did not respond to the start or control request in a timely fashion";
    case ERROR_SERVICE_NO_THREAD                                                  : return "A thread could not be created for the service";
    case ERROR_SERVICE_DATABASE_LOCKED                                            : return "The service database is locked";
    case ERROR_SERVICE_ALREADY_RUNNING                                            : return "An instance of the service is already running";
    case ERROR_INVALID_SERVICE_ACCOUNT                                            : return "The account name is invalid or does not exist, or the password is invalid for the account name specified";
    case ERROR_SERVICE_DISABLED                                                   : return "The service cannot be started, either because it is disabled or because it has no enabled devices associated with it";
    case ERROR_CIRCULAR_DEPENDENCY                                                : return "Circular service dependency was specified";
    case ERROR_SERVICE_DOES_NOT_EXIST                                             : return "The specified service does not exist as an installed service";
    case ERROR_SERVICE_CANNOT_ACCEPT_CTRL                                         : return "The service cannot accept control messages at this time";
    case ERROR_SERVICE_NOT_ACTIVE                                                 : return "The service has not been started";
    case ERROR_FAILED_SERVICE_CONTROLLER_CONNECT                                  : return "The service process could not connect to the service controller";
    case ERROR_EXCEPTION_IN_SERVICE                                               : return "An exception occurred in the service when handling the control request";
    case ERROR_DATABASE_DOES_NOT_EXIST                                            : return "The database specified does not exist";
    case ERROR_SERVICE_SPECIFIC_ERROR                                             : return "The service has returned a service-specific error code";
    case ERROR_PROCESS_ABORTED                                                    : return "The process terminated unexpectedly";
    case ERROR_SERVICE_DEPENDENCY_FAIL                                            : return "The dependency service or group failed to start";
    case ERROR_SERVICE_LOGON_FAILED                                               : return "The service did not start due to a logon failure";
    case ERROR_SERVICE_START_HANG                                                 : return "After starting, the service hung in a start-pending state";
    case ERROR_INVALID_SERVICE_LOCK                                               : return "The specified service database lock is invalid";
    case ERROR_SERVICE_MARKED_FOR_DELETE                                          : return "The specified service has been marked for deletion";
    case ERROR_SERVICE_EXISTS                                                     : return "The specified service already exists";
    case ERROR_ALREADY_RUNNING_LKG                                                : return "The system is currently running with the last-known-good configuration";
    case ERROR_SERVICE_DEPENDENCY_DELETED                                         : return "The dependency service does not exist or has been marked for deletion";
    case ERROR_BOOT_ALREADY_ACCEPTED                                              : return "The current boot has already been accepted for use as the last-known-good control set";
    case ERROR_SERVICE_NEVER_STARTED                                              : return "No attempts to start the service have been made since the last boot";
    case ERROR_DUPLICATE_SERVICE_NAME                                             : return "The name is already in use as either a service name or a service display name";
    case ERROR_DIFFERENT_SERVICE_ACCOUNT                                          : return "The account specified for this service is different from the account specified for other services running in the same process";
    case ERROR_CANNOT_DETECT_DRIVER_FAILURE                                       : return "Failure actions can only be set for Win32 services, not for drivers";
    case ERROR_CANNOT_DETECT_PROCESS_ABORT                                        : return "This service runs in the same process as the service control manager";
    case ERROR_NO_RECOVERY_PROGRAM                                                : return "No recovery program has been configured for this service";
    case ERROR_SERVICE_NOT_IN_EXE                                                 : return "The executable program that this service is configured to run in does not implement the service";
    case ERROR_NOT_SAFEBOOT_SERVICE                                               : return "This service cannot be started in Safe Mode";
    case ERROR_END_OF_MEDIA                                                       : return "The physical end of the tape has been reached";
    case ERROR_FILEMARK_DETECTED                                                  : return "A tape access reached a filemark";
    case ERROR_BEGINNING_OF_MEDIA                                                 : return "The beginning of the tape or a partition was encountered";
    case ERROR_SETMARK_DETECTED                                                   : return "A tape access reached the end of a set of files";
    case ERROR_NO_DATA_DETECTED                                                   : return "No more data is on the tape";
    case ERROR_PARTITION_FAILURE                                                  : return "Tape could not be partitioned";
    case ERROR_INVALID_BLOCK_LENGTH                                               : return "When accessing a new tape of a multivolume partition, the current block size is incorrect";
    case ERROR_DEVICE_NOT_PARTITIONED                                             : return "Tape partition information could not be found when loading a tape";
    case ERROR_UNABLE_TO_LOCK_MEDIA                                               : return "Unable to lock the media eject mechanism";
    case ERROR_UNABLE_TO_UNLOAD_MEDIA                                             : return "Unable to unload the media";
    case ERROR_MEDIA_CHANGED                                                      : return "The media in the drive may have changed";
    case ERROR_BUS_RESET                                                          : return "The I/O bus was reset";
    case ERROR_NO_MEDIA_IN_DRIVE                                                  : return "No media in drive";
    case ERROR_NO_UNICODE_TRANSLATION                                             : return "No mapping for the Unicode character exists in the target multi-byte code page";
    case ERROR_DLL_INIT_FAILED                                                    : return "A dynamic link library (DLL) initialization routine failed";
    case ERROR_SHUTDOWN_IN_PROGRESS                                               : return "A system shutdown is in progress";
    case ERROR_NO_SHUTDOWN_IN_PROGRESS                                            : return "Unable to abort the system shutdown because no shutdown was in progress";
    case ERROR_IO_DEVICE                                                          : return "The request could not be performed because of an I/O device error";
    case ERROR_SERIAL_NO_DEVICE                                                   : return "No serial device was successfully initialized. The serial driver will unload";
    case ERROR_IRQ_BUSY                                                           : return "Unable to open a device that was sharing an interrupt request (IRQ) with other devices. At least one other device that uses that IRQ was already opened";
    case ERROR_MORE_WRITES                                                        : return "A serial I/O operation was completed by another write to the serial port";
    case ERROR_COUNTER_TIMEOUT                                                    : return "A serial I/O operation completed because the timeout period expired";
    case ERROR_FLOPPY_ID_MARK_NOT_FOUND                                           : return "No ID address mark was found on the floppy disk";
    case ERROR_FLOPPY_WRONG_CYLINDER                                              : return "Mismatch between the floppy disk sector ID field and the floppy disk controller track address";
    case ERROR_FLOPPY_UNKNOWN_ERROR                                               : return "The floppy disk controller reported an error that is not recognized by the floppy disk driver";
    case ERROR_FLOPPY_BAD_REGISTERS                                               : return "The floppy disk controller returned inconsistent results in its registers";
    case ERROR_DISK_RECALIBRATE_FAILED                                            : return "While accessing the hard disk, a recalibrate operation failed, even after retries";
    case ERROR_DISK_OPERATION_FAILED                                              : return "While accessing the hard disk, a disk operation failed even after retries";
    case ERROR_DISK_RESET_FAILED                                                  : return "While accessing the hard disk, a disk controller reset was needed, but even that failed";
    case ERROR_EOM_OVERFLOW                                                       : return "Physical end of tape encountered";
    case ERROR_NOT_ENOUGH_SERVER_MEMORY                                           : return "Not enough server storage is available to process this command";
    case ERROR_POSSIBLE_DEADLOCK                                                  : return "A potential deadlock condition has been detected";
    case ERROR_MAPPED_ALIGNMENT                                                   : return "The base address or the file offset specified does not have the proper alignment";
    case ERROR_SET_POWER_STATE_VETOED                                             : return "An attempt to change the system power state was vetoed by another application or driver";
    case ERROR_SET_POWER_STATE_FAILED                                             : return "The system BIOS failed an attempt to change the system power state";
    case ERROR_TOO_MANY_LINKS                                                     : return "An attempt was made to create more links on a file than the file system supports";
    case ERROR_OLD_WIN_VERSION                                                    : return "The specified program requires a newer version of Windows";
    case ERROR_APP_WRONG_OS                                                       : return "The specified program is not a Windows or MS-DOS program";
    case ERROR_SINGLE_INSTANCE_APP                                                : return "Cannot start more than one instance of the specified program";
    case ERROR_RMODE_APP                                                          : return "The specified program was written for an earlier version of Windows";
    case ERROR_INVALID_DLL                                                        : return "One of the library files needed to run this application is damaged";
    case ERROR_NO_ASSOCIATION                                                     : return "No application is associated with the specified file for this operation";
    case ERROR_DDE_FAIL                                                           : return "An error occurred in sending the command to the application";
    case ERROR_DLL_NOT_FOUND                                                      : return "One of the library files needed to run this application cannot be found";
    case ERROR_NO_MORE_USER_HANDLES                                               : return "The current process has used all of its system allowance of handles for Window Manager objects";
    case ERROR_MESSAGE_SYNC_ONLY                                                  : return "The message can be used only with synchronous operations";
    case ERROR_SOURCE_ELEMENT_EMPTY                                               : return "The indicated source element has no media";
    case ERROR_DESTINATION_ELEMENT_FULL                                           : return "The indicated destination element already contains media";
    case ERROR_ILLEGAL_ELEMENT_ADDRESS                                            : return "The indicated element does not exist";
    case ERROR_MAGAZINE_NOT_PRESENT                                               : return "The indicated element is part of a magazine that is not present";
    case ERROR_DEVICE_REINITIALIZATION_NEEDED                                     : return "The indicated device requires reinitialization due to hardware errors";
    case ERROR_DEVICE_REQUIRES_CLEANING                                           : return "The device has indicated that cleaning is required before further operations are attempted";
    case ERROR_DEVICE_DOOR_OPEN                                                   : return "The device has indicated that its door is open";
    case ERROR_DEVICE_NOT_CONNECTED                                               : return "The device is not connected";
    case ERROR_NOT_FOUND                                                          : return "Element not found";
    case ERROR_NO_MATCH                                                           : return "There was no match for the specified key in the index";
    case ERROR_SET_NOT_FOUND                                                      : return "The property set specified does not exist on the object";
    case ERROR_POINT_NOT_FOUND                                                    : return "The point passed to GetMouseMovePoints is not in the buffer";
    case ERROR_NO_TRACKING_SERVICE                                                : return "The tracking (workstation) service is not running";
    case ERROR_NO_VOLUME_ID                                                       : return "The Volume ID could not be found";
    case ERROR_UNABLE_TO_REMOVE_REPLACED                                          : return "Unable to remove the file to be replaced";
    case ERROR_UNABLE_TO_MOVE_REPLACEMENT                                         : return "Unable to move the replacement file to the file to be replaced. The file to be replaced has retained its original name";
    case ERROR_UNABLE_TO_MOVE_REPLACEMENT_2                                       : return "Unable to move the replacement file to the file to be replaced. The file to be replaced has been renamed using the backup name";
    case ERROR_JOURNAL_DELETE_IN_PROGRESS                                         : return "The volume change journal is being deleted";
    case ERROR_JOURNAL_NOT_ACTIVE                                                 : return "The volume change journal is not active";
    case ERROR_POTENTIAL_FILE_FOUND                                               : return "A file was found, but it may not be the correct file";
    case ERROR_JOURNAL_ENTRY_DELETED                                              : return "The journal entry has been deleted from the journal";
    case ERROR_SHUTDOWN_IS_SCHEDULED                                              : return "A system shutdown has already been scheduled";
    case ERROR_SHUTDOWN_USERS_LOGGED_ON                                           : return "The system shutdown cannot be initiated because there are other users logged on to the computer";
    case ERROR_BAD_DEVICE                                                         : return "The specified device name is invalid";
    case ERROR_CONNECTION_UNAVAIL                                                 : return "The device is not currently connected but it is a remembered connection";
    case ERROR_DEVICE_ALREADY_REMEMBERED                                          : return "The local device name has a remembered connection to another network resource";
    case ERROR_NO_NET_OR_BAD_PATH                                                 : return "The network path was either typed incorrectly, does not exist, or the network provider is not currently available. Please try retyping the path or contact your network administrator";
    case ERROR_BAD_PROVIDER                                                       : return "The specified network provider name is invalid";
    case ERROR_CANNOT_OPEN_PROFILE                                                : return "Unable to open the network connection profile";
    case ERROR_BAD_PROFILE                                                        : return "The network connection profile is corrupted";
    case ERROR_NOT_CONTAINER                                                      : return "Cannot enumerate a noncontainer";
    case ERROR_EXTENDED_ERROR                                                     : return "An extended error has occurred";
    case ERROR_INVALID_GROUPNAME                                                  : return "The format of the specified group name is invalid";
    case ERROR_INVALID_COMPUTERNAME                                               : return "The format of the specified computer name is invalid";
    case ERROR_INVALID_EVENTNAME                                                  : return "The format of the specified event name is invalid";
    case ERROR_INVALID_DOMAINNAME                                                 : return "The format of the specified domain name is invalid";
    case ERROR_INVALID_SERVICENAME                                                : return "The format of the specified service name is invalid";
    case ERROR_INVALID_NETNAME                                                    : return "The format of the specified network name is invalid";
    case ERROR_INVALID_SHARENAME                                                  : return "The format of the specified share name is invalid";
    case ERROR_INVALID_PASSWORDNAME                                               : return "The format of the specified password is invalid";
    case ERROR_INVALID_MESSAGENAME                                                : return "The format of the specified message name is invalid";
    case ERROR_INVALID_MESSAGEDEST                                                : return "The format of the specified message destination is invalid";
    case ERROR_SESSION_CREDENTIAL_CONFLICT                                        : return "Multiple connections to a server or shared resource by the same user, using more than one user name, are not allowed. Disconnect all previous connections to the server or shared resource and try again";
    case ERROR_REMOTE_SESSION_LIMIT_EXCEEDED                                      : return "An attempt was made to establish a session to a network server, but there are already too many sessions established to that server";
    case ERROR_DUP_DOMAINNAME                                                     : return "The workgroup or domain name is already in use by another computer on the network";
    case ERROR_NO_NETWORK                                                         : return "The network is not present or not started";
    case ERROR_CANCELLED                                                          : return "The operation was canceled by the user";
    case ERROR_USER_MAPPED_FILE                                                   : return "The requested operation cannot be performed on a file with a user-mapped section open";
    case ERROR_CONNECTION_REFUSED                                                 : return "The remote computer refused the network connection";
    case ERROR_GRACEFUL_DISCONNECT                                                : return "The network connection was gracefully closed";
    case ERROR_ADDRESS_ALREADY_ASSOCIATED                                         : return "The network transport endpoint already has an address associated with it";
    case ERROR_ADDRESS_NOT_ASSOCIATED                                             : return "An address has not yet been associated with the network endpoint";
    case ERROR_CONNECTION_INVALID                                                 : return "An operation was attempted on a nonexistent network connection";
    case ERROR_CONNECTION_ACTIVE                                                  : return "An invalid operation was attempted on an active network connection";
    case ERROR_NETWORK_UNREACHABLE                                                : return "The network location cannot be reached. For information about network troubleshooting, see Windows Help";
    case ERROR_HOST_UNREACHABLE                                                   : return "The network location cannot be reached. For information about network troubleshooting, see Windows Help";
    case ERROR_PROTOCOL_UNREACHABLE                                               : return "The network location cannot be reached. For information about network troubleshooting, see Windows Help";
    case ERROR_PORT_UNREACHABLE                                                   : return "No service is operating at the destination network endpoint on the remote system";
    case ERROR_REQUEST_ABORTED                                                    : return "The request was aborted";
    case ERROR_CONNECTION_ABORTED                                                 : return "The network connection was aborted by the local system";
    case ERROR_RETRY                                                              : return "The operation could not be completed. A retry should be performed";
    case ERROR_CONNECTION_COUNT_LIMIT                                             : return "A connection to the server could not be made because the limit on the number of concurrent connections for this account has been reached";
    case ERROR_LOGIN_TIME_RESTRICTION                                             : return "Attempting to log in during an unauthorized time of day for this account";
    case ERROR_LOGIN_WKSTA_RESTRICTION                                            : return "The account is not authorized to log in from this station";
    case ERROR_INCORRECT_ADDRESS                                                  : return "The network address could not be used for the operation requested";
    case ERROR_ALREADY_REGISTERED                                                 : return "The service is already registered";
    case ERROR_SERVICE_NOT_FOUND                                                  : return "The specified service does not exist";
    case ERROR_NOT_AUTHENTICATED                                                  : return "The operation being requested was not performed because the user has not been authenticated";
    case ERROR_NOT_LOGGED_ON                                                      : return "The operation being requested was not performed because the user has not logged on to the network. The specified service does not exist";
    case ERROR_CONTINUE                                                           : return "Continue with work in progress";
    case ERROR_ALREADY_INITIALIZED                                                : return "An attempt was made to perform an initialization operation when initialization has already been completed";
    case ERROR_NO_MORE_DEVICES                                                    : return "No more local devices";
    case ERROR_NO_SUCH_SITE                                                       : return "The specified site does not exist";
    case ERROR_DOMAIN_CONTROLLER_EXISTS                                           : return "A domain controller with the specified name already exists";
    case ERROR_ONLY_IF_CONNECTED                                                  : return "This operation is supported only when you are connected to the server";
    case ERROR_OVERRIDE_NOCHANGES                                                 : return "The group policy framework should call the extension even if there are no changes";
    case ERROR_BAD_USER_PROFILE                                                   : return "The specified user does not have a valid profile";
    case ERROR_NOT_SUPPORTED_ON_SBS                                               : return "This operation is not supported on a computer running Windows Server 2003 for Small Business Server";
    case ERROR_SERVER_SHUTDOWN_IN_PROGRESS                                        : return "The server machine is shutting down";
    case ERROR_HOST_DOWN                                                          : return "The remote system is not available. For information about network troubleshooting, see Windows Help";
    case ERROR_NON_ACCOUNT_SID                                                    : return "The security identifier provided is not from an account domain";
    case ERROR_NON_DOMAIN_SID                                                     : return "The security identifier provided does not have a domain component";
    case ERROR_APPHELP_BLOCK                                                      : return "AppHelp dialog canceled thus preventing the application from starting";
    case ERROR_ACCESS_DISABLED_BY_POLICY                                          : return "This program is blocked by group policy. For more information, contact your system administrator";
    case ERROR_REG_NAT_CONSUMPTION                                                : return "A program attempt to use an invalid register value. Normally caused by an uninitialized register. This error is Itanium specific";
    case ERROR_CSCSHARE_OFFLINE                                                   : return "The share is currently offline or does not exist";
    case ERROR_PKINIT_FAILURE                                                     : return "The Kerberos protocol encountered an error while validating the KDC certificate during smartcard logon. There is more information in the system event log";
    case ERROR_SMARTCARD_SUBSYSTEM_FAILURE                                        : return "The Kerberos protocol encountered an error while attempting to utilize the smartcard subsystem";
    case ERROR_DOWNGRADE_DETECTED                                                 : return "The system cannot contact a domain controller to service the authentication request. Please try again later";
    case ERROR_MACHINE_LOCKED                                                     : return "The machine is locked and cannot be shut down without the force option";
    case ERROR_SMB_GUEST_LOGON_BLOCKED                                            : return "You can't access this shared folder because your organization's security policies block unauthenticated guest access. These policies help protect your PC from unsafe or malicious devices on the network";
    case ERROR_CALLBACK_SUPPLIED_INVALID_DATA                                     : return "An application-defined callback gave invalid data when called";
    case ERROR_SYNC_FOREGROUND_REFRESH_REQUIRED                                   : return "The group policy framework should call the extension in the synchronous foreground policy refresh";
    case ERROR_DRIVER_BLOCKED                                                     : return "This driver has been blocked from loading";
    case ERROR_INVALID_IMPORT_OF_NON_DLL                                          : return "A dynamic link library (DLL) referenced a module that was neither a DLL nor the process's executable image";
    case ERROR_ACCESS_DISABLED_WEBBLADE                                           : return "Windows cannot open this program since it has been disabled";
    case ERROR_ACCESS_DISABLED_WEBBLADE_TAMPER                                    : return "Windows cannot open this program because the license enforcement system has been tampered with or become corrupted";
    case ERROR_RECOVERY_FAILURE                                                   : return "A transaction recover failed";
    case ERROR_ALREADY_FIBER                                                      : return "The current thread has already been converted to a fiber";
    case ERROR_ALREADY_THREAD                                                     : return "The current thread has already been converted from a fiber";
    case ERROR_STACK_BUFFER_OVERRUN                                               : return "The system detected an overrun of a stack-based buffer in this application. This overrun could potentially allow a malicious user to gain control of this application";
    case ERROR_PARAMETER_QUOTA_EXCEEDED                                           : return "Data present in one of the parameters is more than the function can operate on";
    case ERROR_DEBUGGER_INACTIVE                                                  : return "An attempt to do an operation on a debug object failed because the object is in the process of being deleted";
    case ERROR_DELAY_LOAD_FAILED                                                  : return "An attempt to delay-load a .dll or get a function address in a delay-loaded .dll failed";
    case ERROR_VDM_DISALLOWED                                                     : return "%1 is a 16-bit application. You do not have permissions to execute 16-bit applications. Check your permissions with your system administrator";
    case ERROR_UNIDENTIFIED_ERROR                                                 : return "Insufficient information exists to identify the cause of failure";
    case ERROR_INVALID_CRUNTIME_PARAMETER                                         : return "The parameter passed to a C runtime function is incorrect";
    case ERROR_BEYOND_VDL                                                         : return "The operation occurred beyond the valid data length of the file";
    case ERROR_INCOMPATIBLE_SERVICE_SID_TYPE                                      : return "The service start failed since one or more services in the same process have an incompatible service SID type setting. A service with restricted service SID type can only coexist in the same process with other services with a restricted SID type. If the service SID type for this service was just configured, the hosting process must be restarted in order to start this service";
    case ERROR_DRIVER_PROCESS_TERMINATED                                          : return "The process hosting the driver for this device has been terminated";
    case ERROR_IMPLEMENTATION_LIMIT                                               : return "An operation attempted to exceed an implementation-defined limit";
    case ERROR_PROCESS_IS_PROTECTED                                               : return "Either the target process, or the target thread's containing process, is a protected process";
    case ERROR_SERVICE_NOTIFY_CLIENT_LAGGING                                      : return "The service notification client is lagging too far behind the current state of services in the machine";
    case ERROR_DISK_QUOTA_EXCEEDED                                                : return "The requested file operation failed because the storage quota was exceeded";
    case ERROR_CONTENT_BLOCKED                                                    : return "The requested file operation failed because the storage policy blocks that type of file. For more information, contact your system administrator";
    case ERROR_INCOMPATIBLE_SERVICE_PRIVILEGE                                     : return "A privilege that the service requires to function properly does not exist in the service account configuration";
    case ERROR_APP_HANG                                                           : return "A thread involved in this operation appears to be unresponsive";
    case ERROR_INVALID_LABEL                                                      : return "Indicates a particular Security ID may not be assigned as the label of an object";
    case ERROR_NOT_ALL_ASSIGNED                                                   : return "Not all privileges or groups referenced are assigned to the caller";
    case ERROR_SOME_NOT_MAPPED                                                    : return "Some mapping between account names and security IDs was not done";
    case ERROR_NO_QUOTAS_FOR_ACCOUNT                                              : return "No system quota limits are specifically set for this account";
    case ERROR_LOCAL_USER_SESSION_KEY                                             : return "No encryption key is available. A well-known encryption key was returned";
    case ERROR_NULL_LM_PASSWORD                                                   : return "The password is too complex to be converted to a LAN Manager password. The LAN Manager password returned is a NULL string";
    case ERROR_UNKNOWN_REVISION                                                   : return "The revision level is unknown";
    case ERROR_REVISION_MISMATCH                                                  : return "Indicates two revision levels are incompatible";
    case ERROR_INVALID_OWNER                                                      : return "This security ID may not be assigned as the owner of this object";
    case ERROR_INVALID_PRIMARY_GROUP                                              : return "This security ID may not be assigned as the primary group of an object";
    case ERROR_NO_IMPERSONATION_TOKEN                                             : return "An attempt has been made to operate on an impersonation token by a thread that is not currently impersonating a client";
    case ERROR_CANT_DISABLE_MANDATORY                                             : return "The group may not be disabled";
    case ERROR_NO_LOGON_SERVERS                                                   : return "We can't sign you in with this credential because your domain isn't available. Make sure your device is connected to your organization's network and try again. If you previously signed in on this device with another credential, you can sign in with that credential";
    case ERROR_NO_SUCH_LOGON_SESSION                                              : return "A specified logon session does not exist. It may already have been terminated";
    case ERROR_NO_SUCH_PRIVILEGE                                                  : return "A specified privilege does not exist";
    case ERROR_PRIVILEGE_NOT_HELD                                                 : return "A required privilege is not held by the client";
    case ERROR_INVALID_ACCOUNT_NAME                                               : return "The name provided is not a properly formed account name";
    case ERROR_USER_EXISTS                                                        : return "The specified account already exists";
    case ERROR_NO_SUCH_USER                                                       : return "The specified account does not exist";
    case ERROR_GROUP_EXISTS                                                       : return "The specified group already exists";
    case ERROR_NO_SUCH_GROUP                                                      : return "The specified group does not exist";
    case ERROR_MEMBER_IN_GROUP                                                    : return "Either the specified user account is already a member of the specified group, or the specified group cannot be deleted because it contains a member";
    case ERROR_MEMBER_NOT_IN_GROUP                                                : return "The specified user account is not a member of the specified group account";
    case ERROR_LAST_ADMIN                                                         : return "This operation is disallowed as it could result in an administration account being disabled, deleted or unable to logon";
    case ERROR_WRONG_PASSWORD                                                     : return "Unable to update the password. The value provided as the current password is incorrect";
    case ERROR_ILL_FORMED_PASSWORD                                                : return "Unable to update the password. The value provided for the new password contains values that are not allowed in passwords";
    case ERROR_PASSWORD_RESTRICTION                                               : return "Unable to update the password. The value provided for the new password does not meet the length, complexity, or history requirements of the domain";
    case ERROR_LOGON_FAILURE                                                      : return "The user name or password is incorrect";
    case ERROR_ACCOUNT_RESTRICTION                                                : return "Account restrictions are preventing this user from signing in. For example: blank passwords aren't allowed, sign-in times are limited, or a policy restriction has been enforced";
    case ERROR_INVALID_LOGON_HOURS                                                : return "Your account has time restrictions that keep you from signing in right now";
    case ERROR_INVALID_WORKSTATION                                                : return "This user isn't allowed to sign in to this computer";
    case ERROR_PASSWORD_EXPIRED                                                   : return "The password for this account has expired";
    case ERROR_ACCOUNT_DISABLED                                                   : return "This user can't sign in because this account is currently disabled";
    case ERROR_NONE_MAPPED                                                        : return "No mapping between account names and security IDs was done";
    case ERROR_TOO_MANY_LUIDS_REQUESTED                                           : return "Too many local user identifiers (LUIDs) were requested at one time";
    case ERROR_LUIDS_EXHAUSTED                                                    : return "No more local user identifiers (LUIDs) are available";
    case ERROR_INVALID_SUB_AUTHORITY                                              : return "The subauthority part of a security ID is invalid for this particular use";
    case ERROR_INVALID_ACL                                                        : return "The access control list (ACL) structure is invalid";
    case ERROR_INVALID_SID                                                        : return "The security ID structure is invalid";
    case ERROR_INVALID_SECURITY_DESCR                                             : return "The security descriptor structure is invalid";
    case ERROR_BAD_INHERITANCE_ACL                                                : return "The inherited access control list (ACL) or access control entry (ACE) could not be built";
    case ERROR_SERVER_DISABLED                                                    : return "The server is currently disabled";
    case ERROR_SERVER_NOT_DISABLED                                                : return "The server is currently enabled";
    case ERROR_INVALID_ID_AUTHORITY                                               : return "The value provided was an invalid value for an identifier authority";
    case ERROR_ALLOTTED_SPACE_EXCEEDED                                            : return "No more memory is available for security information updates";
    case ERROR_INVALID_GROUP_ATTRIBUTES                                           : return "The specified attributes are invalid, or incompatible with the attributes for the group as a whole";
    case ERROR_BAD_IMPERSONATION_LEVEL                                            : return "Either a required impersonation level was not provided, or the provided impersonation level is invalid";
    case ERROR_CANT_OPEN_ANONYMOUS                                                : return "Cannot open an anonymous level security token";
    case ERROR_BAD_VALIDATION_CLASS                                               : return "The validation information class requested was invalid";
    case ERROR_BAD_TOKEN_TYPE                                                     : return "The type of the token is inappropriate for its attempted use";
    case ERROR_NO_SECURITY_ON_OBJECT                                              : return "Unable to perform a security operation on an object that has no associated security";
    case ERROR_CANT_ACCESS_DOMAIN_INFO                                            : return "Configuration information could not be read from the domain controller, either because the machine is unavailable, or access has been denied";
    case ERROR_INVALID_SERVER_STATE                                               : return "The security account manager (SAM) or local security authority (LSA) server was in the wrong state to perform the security operation";
    case ERROR_INVALID_DOMAIN_STATE                                               : return "The domain was in the wrong state to perform the security operation";
    case ERROR_INVALID_DOMAIN_ROLE                                                : return "This operation is only allowed for the Primary Domain Controller of the domain";
    case ERROR_NO_SUCH_DOMAIN                                                     : return "The specified domain either does not exist or could not be contacted";
    case ERROR_DOMAIN_EXISTS                                                      : return "The specified domain already exists";
    case ERROR_DOMAIN_LIMIT_EXCEEDED                                              : return "An attempt was made to exceed the limit on the number of domains per server";
    case ERROR_INTERNAL_DB_CORRUPTION                                             : return "Unable to complete the requested operation because of either a catastrophic media failure or a data structure corruption on the disk";
    case ERROR_INTERNAL_ERROR                                                     : return "An internal error occurred";
    case ERROR_GENERIC_NOT_MAPPED                                                 : return "Generic access types were contained in an access mask which should already be mapped to nongeneric types";
    case ERROR_BAD_DESCRIPTOR_FORMAT                                              : return "A security descriptor is not in the right format (absolute or self-relative)";
    case ERROR_NOT_LOGON_PROCESS                                                  : return "The requested action is restricted for use by logon processes only. The calling process has not registered as a logon process";
    case ERROR_LOGON_SESSION_EXISTS                                               : return "Cannot start a new logon session with an ID that is already in use";
    case ERROR_NO_SUCH_PACKAGE                                                    : return "A specified authentication package is unknown";
    case ERROR_BAD_LOGON_SESSION_STATE                                            : return "The logon session is not in a state that is consistent with the requested operation";
    case ERROR_LOGON_SESSION_COLLISION                                            : return "The logon session ID is already in use";
    case ERROR_INVALID_LOGON_TYPE                                                 : return "A logon request contained an invalid logon type value";
    case ERROR_CANNOT_IMPERSONATE                                                 : return "Unable to impersonate using a named pipe until data has been read from that pipe";
    case ERROR_RXACT_INVALID_STATE                                                : return "The transaction state of a registry subtree is incompatible with the requested operation";
    case ERROR_RXACT_COMMIT_FAILURE                                               : return "An internal security database corruption has been encountered";
    case ERROR_SPECIAL_ACCOUNT                                                    : return "Cannot perform this operation on built-in accounts";
    case ERROR_SPECIAL_GROUP                                                      : return "Cannot perform this operation on this built-in special group";
    case ERROR_SPECIAL_USER                                                       : return "Cannot perform this operation on this built-in special user";
    case ERROR_MEMBERS_PRIMARY_GROUP                                              : return "The user cannot be removed from a group because the group is currently the user's primary group";
    case ERROR_TOKEN_ALREADY_IN_USE                                               : return "The token is already in use as a primary token";
    case ERROR_NO_SUCH_ALIAS                                                      : return "The specified local group does not exist";
    case ERROR_MEMBER_NOT_IN_ALIAS                                                : return "The specified account name is not a member of the group";
    case ERROR_MEMBER_IN_ALIAS                                                    : return "The specified account name is already a member of the group";
    case ERROR_ALIAS_EXISTS                                                       : return "The specified local group already exists";
    case ERROR_LOGON_NOT_GRANTED                                                  : return "Logon failure: the user has not been granted the requested logon type at this computer";
    case ERROR_TOO_MANY_SECRETS                                                   : return "The maximum number of secrets that may be stored in a single system has been exceeded";
    case ERROR_SECRET_TOO_LONG                                                    : return "The length of a secret exceeds the maximum length allowed";
    case ERROR_INTERNAL_DB_ERROR                                                  : return "The local security authority database contains an internal inconsistency";
    case ERROR_TOO_MANY_CONTEXT_IDS                                               : return "During a logon attempt, the user's security context accumulated too many security IDs";
    case ERROR_LOGON_TYPE_NOT_GRANTED                                             : return "Logon failure: the user has not been granted the requested logon type at this computer";
    case ERROR_NT_CROSS_ENCRYPTION_REQUIRED                                       : return "A cross-encrypted password is necessary to change a user password";
    case ERROR_NO_SUCH_MEMBER                                                     : return "A member could not be added to or removed from the local group because the member does not exist";
    case ERROR_INVALID_MEMBER                                                     : return "A new member could not be added to a local group because the member has the wrong account type";
    case ERROR_TOO_MANY_SIDS                                                      : return "Too many security IDs have been specified";
    case ERROR_LM_CROSS_ENCRYPTION_REQUIRED                                       : return "A cross-encrypted password is necessary to change this user password";
    case ERROR_NO_INHERITANCE                                                     : return "Indicates an ACL contains no inheritable components";
    case ERROR_FILE_CORRUPT                                                       : return "The file or directory is corrupted and unreadable";
    case ERROR_DISK_CORRUPT                                                       : return "The disk structure is corrupted and unreadable";
    case ERROR_NO_USER_SESSION_KEY                                                : return "There is no user session key for the specified logon session";
    case ERROR_LICENSE_QUOTA_EXCEEDED                                             : return "The service being accessed is licensed for a particular number of connections. No more connections can be made to the service at this time because there are already as many connections as the service can accept";
    case ERROR_WRONG_TARGET_NAME                                                  : return "The target account name is incorrect";
    case ERROR_MUTUAL_AUTH_FAILED                                                 : return "Mutual Authentication failed. The server's password is out of date at the domain controller";
    case ERROR_TIME_SKEW                                                          : return "There is a time and/or date difference between the client and server";
    case ERROR_CURRENT_DOMAIN_NOT_ALLOWED                                         : return "This operation cannot be performed on the current domain";
    case ERROR_INVALID_WINDOW_HANDLE                                              : return "Invalid window handle";
    case ERROR_INVALID_MENU_HANDLE                                                : return "Invalid menu handle";
    case ERROR_INVALID_CURSOR_HANDLE                                              : return "Invalid cursor handle";
    case ERROR_INVALID_ACCEL_HANDLE                                               : return "Invalid accelerator table handle";
    case ERROR_INVALID_HOOK_HANDLE                                                : return "Invalid hook handle";
    case ERROR_INVALID_DWP_HANDLE                                                 : return "Invalid handle to a multiple-window position structure";
    case ERROR_TLW_WITH_WSCHILD                                                   : return "Cannot create a top-level child window";
    case ERROR_CANNOT_FIND_WND_CLASS                                              : return "Cannot find window class";
    case ERROR_WINDOW_OF_OTHER_THREAD                                             : return "Invalid window; it belongs to other thread";
    case ERROR_HOTKEY_ALREADY_REGISTERED                                          : return "Hot key is already registered";
    case ERROR_CLASS_ALREADY_EXISTS                                               : return "Class already exists";
    case ERROR_CLASS_DOES_NOT_EXIST                                               : return "Class does not exist";
    case ERROR_CLASS_HAS_WINDOWS                                                  : return "Class still has open windows";
    case ERROR_INVALID_INDEX                                                      : return "Invalid index";
    case ERROR_INVALID_ICON_HANDLE                                                : return "Invalid icon handle";
    case ERROR_PRIVATE_DIALOG_INDEX                                               : return "Using private DIALOG window words";
    case ERROR_LISTBOX_ID_NOT_FOUND                                               : return "The list box identifier was not found";
    case ERROR_NO_WILDCARD_CHARACTERS                                             : return "No wildcards were found";
    case ERROR_CLIPBOARD_NOT_OPEN                                                 : return "Thread does not have a clipboard open";
    case ERROR_HOTKEY_NOT_REGISTERED                                              : return "Hot key is not registered";
    case ERROR_WINDOW_NOT_DIALOG                                                  : return "The window is not a valid dialog window";
    case ERROR_CONTROL_ID_NOT_FOUND                                               : return "Control ID not found";
    case ERROR_INVALID_COMBOBOX_MESSAGE                                           : return "Invalid message for a combo box because it does not have an edit control";
    case ERROR_WINDOW_NOT_COMBOBOX                                                : return "The window is not a combo box";
    case ERROR_INVALID_EDIT_HEIGHT                                                : return "Height must be less than 256";
    case ERROR_DC_NOT_FOUND                                                       : return "Invalid device context (DC) handle";
    case ERROR_INVALID_HOOK_FILTER                                                : return "Invalid hook procedure type";
    case ERROR_INVALID_FILTER_PROC                                                : return "Invalid hook procedure";
    case ERROR_HOOK_NEEDS_HMOD                                                    : return "Cannot set nonlocal hook without a module handle";
    case ERROR_GLOBAL_ONLY_HOOK                                                   : return "This hook procedure can only be set globally";
    case ERROR_JOURNAL_HOOK_SET                                                   : return "The journal hook procedure is already installed";
    case ERROR_HOOK_NOT_INSTALLED                                                 : return "The hook procedure is not installed";
    case ERROR_INVALID_LB_MESSAGE                                                 : return "Invalid message for single-selection list box";
    case ERROR_SETCOUNT_ON_BAD_LB                                                 : return "LB_SETCOUNT sent to non-lazy list box";
    case ERROR_LB_WITHOUT_TABSTOPS                                                : return "This list box does not support tab stops";
    case ERROR_DESTROY_OBJECT_OF_OTHER_THREAD                                     : return "Cannot destroy object created by another thread";
    case ERROR_CHILD_WINDOW_MENU                                                  : return "Child windows cannot have menus";
    case ERROR_NO_SYSTEM_MENU                                                     : return "The window does not have a system menu";
    case ERROR_INVALID_MSGBOX_STYLE                                               : return "Invalid message box style";
    case ERROR_INVALID_SPI_VALUE                                                  : return "Invalid system-wide (SPI_*) parameter";
    case ERROR_SCREEN_ALREADY_LOCKED                                              : return "Screen already locked";
    case ERROR_HWNDS_HAVE_DIFF_PARENT                                             : return "All handles to windows in a multiple-window position structure must have the same parent";
    case ERROR_NOT_CHILD_WINDOW                                                   : return "The window is not a child window";
    case ERROR_INVALID_GW_COMMAND                                                 : return "Invalid GW_* command";
    case ERROR_INVALID_THREAD_ID                                                  : return "Invalid thread identifier";
    case ERROR_NON_MDICHILD_WINDOW                                                : return "Cannot process a message from a window that is not a multiple document interface (MDI) window";
    case ERROR_POPUP_ALREADY_ACTIVE                                               : return "Popup menu already active";
    case ERROR_NO_SCROLLBARS                                                      : return "The window does not have scroll bars";
    case ERROR_INVALID_SCROLLBAR_RANGE                                            : return "Scroll bar range cannot be greater than MAXLONG";
    case ERROR_INVALID_SHOWWIN_COMMAND                                            : return "Cannot show or remove the window in the way specified";
    case ERROR_NO_SYSTEM_RESOURCES                                                : return "Insufficient system resources exist to complete the requested service";
    case ERROR_NONPAGED_SYSTEM_RESOURCES                                          : return "Insufficient system resources exist to complete the requested service";
    case ERROR_PAGED_SYSTEM_RESOURCES                                             : return "Insufficient system resources exist to complete the requested service";
    case ERROR_WORKING_SET_QUOTA                                                  : return "Insufficient quota to complete the requested service";
    case ERROR_PAGEFILE_QUOTA                                                     : return "Insufficient quota to complete the requested service";
    case ERROR_COMMITMENT_LIMIT                                                   : return "The paging file is too small for this operation to complete";
    case ERROR_MENU_ITEM_NOT_FOUND                                                : return "A menu item was not found";
    case ERROR_INVALID_KEYBOARD_HANDLE                                            : return "Invalid keyboard layout handle";
    case ERROR_HOOK_TYPE_NOT_ALLOWED                                              : return "Hook type not allowed";
    case ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION                                 : return "This operation requires an interactive window station";
    case ERROR_TIMEOUT                                                            : return "This operation returned because the timeout period expired";
    case ERROR_INVALID_MONITOR_HANDLE                                             : return "Invalid monitor handle";
    case ERROR_INCORRECT_SIZE                                                     : return "Incorrect size argument";
    case ERROR_SYMLINK_CLASS_DISABLED                                             : return "The symbolic link cannot be followed because its type is disabled";
    case ERROR_SYMLINK_NOT_SUPPORTED                                              : return "This application does not support the current operation on symbolic links";
    case ERROR_XML_PARSE_ERROR                                                    : return "Windows was unable to parse the requested XML data";
    case ERROR_XMLDSIG_ERROR                                                      : return "An error was encountered while processing an XML digital signature";
    case ERROR_RESTART_APPLICATION                                                : return "This application must be restarted";
    case ERROR_WRONG_COMPARTMENT                                                  : return "The caller made the connection request in the wrong routing compartment";
    case ERROR_AUTHIP_FAILURE                                                     : return "There was an AuthIP failure when attempting to connect to the remote host";
    case ERROR_NO_NVRAM_RESOURCES                                                 : return "Insufficient NVRAM resources exist to complete the requested service. A reboot might be required";
    case ERROR_NOT_GUI_PROCESS                                                    : return "Unable to finish the requested operation because the specified process is not a GUI process";
    case ERROR_EVENTLOG_FILE_CORRUPT                                              : return "The event log file is corrupted";
    case ERROR_EVENTLOG_CANT_START                                                : return "No event log file could be opened, so the event logging service did not start";
    case ERROR_LOG_FILE_FULL                                                      : return "The event log file is full";
    case ERROR_EVENTLOG_FILE_CHANGED                                              : return "The event log file has changed between read operations";
    case ERROR_CONTAINER_ASSIGNED                                                 : return "The specified Job already has a container assigned to it";
    case ERROR_JOB_NO_CONTAINER                                                   : return "The specified Job does not have a container assigned to it";
    case ERROR_INVALID_TASK_NAME                                                  : return "The specified task name is invalid";
    case ERROR_INVALID_TASK_INDEX                                                 : return "The specified task index is invalid";
    case ERROR_THREAD_ALREADY_IN_TASK                                             : return "The specified thread is already joining a task";
    case ERROR_INSTALL_SERVICE_FAILURE                                            : return "The Windows Installer Service could not be accessed. This can occur if the Windows Installer is not correctly installed. Contact your support personnel for assistance";
    case ERROR_INSTALL_USEREXIT                                                   : return "User cancelled installation";
    case ERROR_INSTALL_FAILURE                                                    : return "Fatal error during installation";
    case ERROR_INSTALL_SUSPEND                                                    : return "Installation suspended, incomplete";
    case ERROR_UNKNOWN_PRODUCT                                                    : return "This action is only valid for products that are currently installed";
    case ERROR_UNKNOWN_FEATURE                                                    : return "Feature ID not registered";
    case ERROR_UNKNOWN_COMPONENT                                                  : return "Component ID not registered";
    case ERROR_UNKNOWN_PROPERTY                                                   : return "Unknown property";
    case ERROR_INVALID_HANDLE_STATE                                               : return "Handle is in an invalid state";
    case ERROR_BAD_CONFIGURATION                                                  : return "The configuration data for this product is corrupt. Contact your support personnel";
    case ERROR_INDEX_ABSENT                                                       : return "Component qualifier not present";
    case ERROR_INSTALL_SOURCE_ABSENT                                              : return "The installation source for this product is not available. Verify that the source exists and that you can access it";
    case ERROR_INSTALL_PACKAGE_VERSION                                            : return "This installation package cannot be installed by the Windows Installer service. You must install a Windows service pack that contains a newer version of the Windows Installer service";
    case ERROR_PRODUCT_UNINSTALLED                                                : return "Product is uninstalled";
    case ERROR_BAD_QUERY_SYNTAX                                                   : return "SQL query syntax invalid or unsupported";
    case ERROR_INVALID_FIELD                                                      : return "Record field does not exist";
    case ERROR_DEVICE_REMOVED                                                     : return "The device has been removed";
    case ERROR_INSTALL_ALREADY_RUNNING                                            : return "Another installation is already in progress. Complete that installation before proceeding with this install";
    case ERROR_INSTALL_PACKAGE_OPEN_FAILED                                        : return "This installation package could not be opened. Verify that the package exists and that you can access it, or contact the application vendor to verify that this is a valid Windows Installer package";
    case ERROR_INSTALL_PACKAGE_INVALID                                            : return "This installation package could not be opened. Contact the application vendor to verify that this is a valid Windows Installer package";
    case ERROR_INSTALL_UI_FAILURE                                                 : return "There was an error starting the Windows Installer service user interface. Contact your support personnel";
    case ERROR_INSTALL_LOG_FAILURE                                                : return "Error opening installation log file. Verify that the specified log file location exists and that you can write to it";
    case ERROR_INSTALL_LANGUAGE_UNSUPPORTED                                       : return "The language of this installation package is not supported by your system";
    case ERROR_INSTALL_TRANSFORM_FAILURE                                          : return "Error applying transforms. Verify that the specified transform paths are valid";
    case ERROR_INSTALL_PACKAGE_REJECTED                                           : return "This installation is forbidden by system policy. Contact your system administrator";
    case ERROR_FUNCTION_NOT_CALLED                                                : return "Function could not be executed";
    case ERROR_FUNCTION_FAILED                                                    : return "Function failed during execution";
    case ERROR_INVALID_TABLE                                                      : return "Invalid or unknown table specified";
    case ERROR_DATATYPE_MISMATCH                                                  : return "Data supplied is of wrong type";
    case ERROR_UNSUPPORTED_TYPE                                                   : return "Data of this type is not supported";
    case ERROR_CREATE_FAILED                                                      : return "The Windows Installer service failed to start. Contact your support personnel";
    case ERROR_INSTALL_TEMP_UNWRITABLE                                            : return "The Temp folder is on a drive that is full or is inaccessible. Free up space on the drive or verify that you have write permission on the Temp folder";
    case ERROR_INSTALL_PLATFORM_UNSUPPORTED                                       : return "This installation package is not supported by this processor type. Contact your product vendor";
    case ERROR_INSTALL_NOTUSED                                                    : return "Component not used on this computer";
    case ERROR_PATCH_PACKAGE_OPEN_FAILED                                          : return "This update package could not be opened. Verify that the update package exists and that you can access it, or contact the application vendor to verify that this is a valid Windows Installer update package";
    case ERROR_PATCH_PACKAGE_INVALID                                              : return "This update package could not be opened. Contact the application vendor to verify that this is a valid Windows Installer update package";
    case ERROR_PATCH_PACKAGE_UNSUPPORTED                                          : return "This update package cannot be processed by the Windows Installer service. You must install a Windows service pack that contains a newer version of the Windows Installer service";
    case ERROR_PRODUCT_VERSION                                                    : return "Another version of this product is already installed. Installation of this version cannot continue. To configure or remove the existing version of this product, use Add/Remove Programs on the Control Panel";
    case ERROR_INVALID_COMMAND_LINE                                               : return "Invalid command line argument. Consult the Windows Installer SDK for detailed command line help";
    case ERROR_INSTALL_REMOTE_DISALLOWED                                          : return "Only administrators have permission to add, remove, or configure server software during a Terminal services remote session. If you want to install or configure software on the server, contact your network administrator";
    case ERROR_SUCCESS_REBOOT_INITIATED                                           : return "The requested operation completed successfully. The system will be restarted so the changes can take effect";
    case ERROR_PATCH_TARGET_NOT_FOUND                                             : return "The upgrade cannot be installed by the Windows Installer service because the program to be upgraded may be missing, or the upgrade may update a different version of the program. Verify that the program to be upgraded exists on your computer and that you have the correct upgrade";
    case ERROR_PATCH_PACKAGE_REJECTED                                             : return "The update package is not permitted by software restriction policy";
    case ERROR_INSTALL_TRANSFORM_REJECTED                                         : return "One or more customizations are not permitted by software restriction policy";
    case ERROR_INSTALL_REMOTE_PROHIBITED                                          : return "The Windows Installer does not permit installation from a Remote Desktop Connection";
    case ERROR_PATCH_REMOVAL_UNSUPPORTED                                          : return "Uninstallation of the update package is not supported";
    case ERROR_UNKNOWN_PATCH                                                      : return "The update is not applied to this product";
    case ERROR_PATCH_NO_SEQUENCE                                                  : return "No valid sequence could be found for the set of updates";
    case ERROR_PATCH_REMOVAL_DISALLOWED                                           : return "Update removal was disallowed by policy";
    case ERROR_INVALID_PATCH_XML                                                  : return "The XML update data is invalid";
    case ERROR_PATCH_MANAGED_ADVERTISED_PRODUCT                                   : return "Windows Installer does not permit updating of managed advertised products. At least one feature of the product must be installed before applying the update";
    case ERROR_INSTALL_SERVICE_SAFEBOOT                                           : return "The Windows Installer service is not accessible in Safe Mode. Please try again when your computer is not in Safe Mode or you can use System Restore to return your machine to a previous good state";
    case ERROR_FAIL_FAST_EXCEPTION                                                : return "A fail fast exception occurred. Exception handlers will not be invoked and the process will be terminated immediately";
    case ERROR_INSTALL_REJECTED                                                   : return "The app that you are trying to run is not supported on this version of Windows";
    case ERROR_DYNAMIC_CODE_BLOCKED                                               : return "The operation was blocked as the process prohibits dynamic code generation";
    case ERROR_NOT_SAME_OBJECT                                                    : return "The objects are not identical";
    case ERROR_STRICT_CFG_VIOLATION                                               : return "The specified image file was blocked from loading because it does not enable a feature required by the process: Control Flow Guard";
    case ERROR_SET_CONTEXT_DENIED                                                 : return "The thread context could not be updated because this has been restricted for the process";
    case ERROR_CROSS_PARTITION_VIOLATION                                          : return "An invalid cross-partition private file/section access was attempted";
    case RPC_S_INVALID_STRING_BINDING                                             : return "The string binding is invalid";
    case RPC_S_WRONG_KIND_OF_BINDING                                              : return "The binding handle is not the correct type";
    case RPC_S_INVALID_BINDING                                                    : return "The binding handle is invalid";
    case RPC_S_PROTSEQ_NOT_SUPPORTED                                              : return "The RPC protocol sequence is not supported";
    case RPC_S_INVALID_RPC_PROTSEQ                                                : return "The RPC protocol sequence is invalid";
    case RPC_S_INVALID_STRING_UUID                                                : return "The string universal unique identifier (UUID) is invalid";
    case RPC_S_INVALID_ENDPOINT_FORMAT                                            : return "The endpoint format is invalid";
    case RPC_S_INVALID_NET_ADDR                                                   : return "The network address is invalid";
    case RPC_S_NO_ENDPOINT_FOUND                                                  : return "No endpoint was found";
    case RPC_S_INVALID_TIMEOUT                                                    : return "The timeout value is invalid";
    case RPC_S_OBJECT_NOT_FOUND                                                   : return "The object universal unique identifier (UUID) was not found";
    case RPC_S_ALREADY_REGISTERED                                                 : return "The object universal unique identifier (UUID) has already been registered";
    case RPC_S_TYPE_ALREADY_REGISTERED                                            : return "The type universal unique identifier (UUID) has already been registered";
    case RPC_S_ALREADY_LISTENING                                                  : return "The RPC server is already listening";
    case RPC_S_NO_PROTSEQS_REGISTERED                                             : return "No protocol sequences have been registered";
    case RPC_S_NOT_LISTENING                                                      : return "The RPC server is not listening";
    case RPC_S_UNKNOWN_MGR_TYPE                                                   : return "The manager type is unknown";
    case RPC_S_UNKNOWN_IF                                                         : return "The interface is unknown";
    case RPC_S_NO_BINDINGS                                                        : return "There are no bindings";
    case RPC_S_NO_PROTSEQS                                                        : return "There are no protocol sequences";
    case RPC_S_CANT_CREATE_ENDPOINT                                               : return "The endpoint cannot be created";
    case RPC_S_OUT_OF_RESOURCES                                                   : return "Not enough resources are available to complete this operation";
    case RPC_S_SERVER_UNAVAILABLE                                                 : return "The RPC server is unavailable";
    case RPC_S_SERVER_TOO_BUSY                                                    : return "The RPC server is too busy to complete this operation";
    case RPC_S_INVALID_NETWORK_OPTIONS                                            : return "The network options are invalid";
    case RPC_S_NO_CALL_ACTIVE                                                     : return "There are no remote procedure calls active on this thread";
    case RPC_S_CALL_FAILED                                                        : return "The remote procedure call failed";
    case RPC_S_CALL_FAILED_DNE                                                    : return "The remote procedure call failed and did not execute";
    case RPC_S_PROTOCOL_ERROR                                                     : return "A remote procedure call (RPC) protocol error occurred";
    case RPC_S_PROXY_ACCESS_DENIED                                                : return "Access to the HTTP proxy is denied";
    case RPC_S_UNSUPPORTED_TRANS_SYN                                              : return "The transfer syntax is not supported by the RPC server";
    case RPC_S_UNSUPPORTED_TYPE                                                   : return "The universal unique identifier (UUID) type is not supported";
    case RPC_S_INVALID_TAG                                                        : return "The tag is invalid";
    case RPC_S_INVALID_BOUND                                                      : return "The array bounds are invalid";
    case RPC_S_NO_ENTRY_NAME                                                      : return "The binding does not contain an entry name";
    case RPC_S_INVALID_NAME_SYNTAX                                                : return "The name syntax is invalid";
    case RPC_S_UNSUPPORTED_NAME_SYNTAX                                            : return "The name syntax is not supported";
    case RPC_S_UUID_NO_ADDRESS                                                    : return "No network address is available to use to construct a universal unique identifier (UUID)";
    case RPC_S_DUPLICATE_ENDPOINT                                                 : return "The endpoint is a duplicate";
    case RPC_S_UNKNOWN_AUTHN_TYPE                                                 : return "The authentication type is unknown";
    case RPC_S_MAX_CALLS_TOO_SMALL                                                : return "The maximum number of calls is too small";
    case RPC_S_STRING_TOO_LONG                                                    : return "The string is too long";
    case RPC_S_PROTSEQ_NOT_FOUND                                                  : return "The RPC protocol sequence was not found";
    case RPC_S_PROCNUM_OUT_OF_RANGE                                               : return "The procedure number is out of range";
    case RPC_S_BINDING_HAS_NO_AUTH                                                : return "The binding does not contain any authentication information";
    case RPC_S_UNKNOWN_AUTHN_SERVICE                                              : return "The authentication service is unknown";
    case RPC_S_UNKNOWN_AUTHN_LEVEL                                                : return "The authentication level is unknown";
    case RPC_S_INVALID_AUTH_IDENTITY                                              : return "The security context is invalid";
    case RPC_S_UNKNOWN_AUTHZ_SERVICE                                              : return "The authorization service is unknown";
    case EPT_S_INVALID_ENTRY                                                      : return "The entry is invalid";
    case EPT_S_CANT_PERFORM_OP                                                    : return "The server endpoint cannot perform the operation";
    case EPT_S_NOT_REGISTERED                                                     : return "There are no more endpoints available from the endpoint mapper";
    case RPC_S_NOTHING_TO_EXPORT                                                  : return "No interfaces have been exported";
    case RPC_S_INCOMPLETE_NAME                                                    : return "The entry name is incomplete";
    case RPC_S_INVALID_VERS_OPTION                                                : return "The version option is invalid";
    case RPC_S_NO_MORE_MEMBERS                                                    : return "There are no more members";
    case RPC_S_NOT_ALL_OBJS_UNEXPORTED                                            : return "There is nothing to unexport";
    case RPC_S_INTERFACE_NOT_FOUND                                                : return "The interface was not found";
    case RPC_S_ENTRY_ALREADY_EXISTS                                               : return "The entry already exists";
    case RPC_S_ENTRY_NOT_FOUND                                                    : return "The entry is not found";
    case RPC_S_NAME_SERVICE_UNAVAILABLE                                           : return "The name service is unavailable";
    case RPC_S_INVALID_NAF_ID                                                     : return "The network address family is invalid";
    case RPC_S_CANNOT_SUPPORT                                                     : return "The requested operation is not supported";
    case RPC_S_NO_CONTEXT_AVAILABLE                                               : return "No security context is available to allow impersonation";
    case RPC_S_INTERNAL_ERROR                                                     : return "An internal error occurred in a remote procedure call (RPC)";
    case RPC_S_ZERO_DIVIDE                                                        : return "The RPC server attempted an integer division by zero";
    case RPC_S_ADDRESS_ERROR                                                      : return "An addressing error occurred in the RPC server";
    case RPC_S_FP_DIV_ZERO                                                        : return "A floating-point operation at the RPC server caused a division by zero";
    case RPC_S_FP_UNDERFLOW                                                       : return "A floating-point underflow occurred at the RPC server";
    case RPC_S_FP_OVERFLOW                                                        : return "A floating-point overflow occurred at the RPC server";
    case RPC_X_NO_MORE_ENTRIES                                                    : return "The list of RPC servers available for the binding of auto handles has been exhausted";
    case RPC_X_SS_CHAR_TRANS_OPEN_FAIL                                            : return "Unable to open the character translation table file";
    case RPC_X_SS_CHAR_TRANS_SHORT_FILE                                           : return "The file containing the character translation table has fewer than 512 bytes";
    case RPC_X_SS_IN_NULL_CONTEXT                                                 : return "A null context handle was passed from the client to the host during a remote procedure call";
    case RPC_X_SS_CONTEXT_DAMAGED                                                 : return "The context handle changed during a remote procedure call";
    case RPC_X_SS_HANDLES_MISMATCH                                                : return "The binding handles passed to a remote procedure call do not match";
    case RPC_X_SS_CANNOT_GET_CALL_HANDLE                                          : return "The stub is unable to get the remote procedure call handle";
    case RPC_X_NULL_REF_POINTER                                                   : return "A null reference pointer was passed to the stub";
    case RPC_X_ENUM_VALUE_OUT_OF_RANGE                                            : return "The enumeration value is out of range";
    case RPC_X_BYTE_COUNT_TOO_SMALL                                               : return "The byte count is too small";
    case RPC_X_BAD_STUB_DATA                                                      : return "The stub received bad data";
    case ERROR_INVALID_USER_BUFFER                                                : return "The supplied user buffer is not valid for the requested operation";
    case ERROR_UNRECOGNIZED_MEDIA                                                 : return "The disk media is not recognized. It may not be formatted";
    case ERROR_NO_TRUST_LSA_SECRET                                                : return "The workstation does not have a trust secret";
    case ERROR_NO_TRUST_SAM_ACCOUNT                                               : return "The security database on the server does not have a computer account for this workstation trust relationship";
    case ERROR_TRUSTED_DOMAIN_FAILURE                                             : return "The trust relationship between the primary domain and the trusted domain failed";
    case ERROR_TRUSTED_RELATIONSHIP_FAILURE                                       : return "The trust relationship between this workstation and the primary domain failed";
    case ERROR_TRUST_FAILURE                                                      : return "The network logon failed";
    case RPC_S_CALL_IN_PROGRESS                                                   : return "A remote procedure call is already in progress for this thread";
    case ERROR_NETLOGON_NOT_STARTED                                               : return "An attempt was made to logon, but the network logon service was not started";
    case ERROR_ACCOUNT_EXPIRED                                                    : return "The user's account has expired";
    case ERROR_REDIRECTOR_HAS_OPEN_HANDLES                                        : return "The redirector is in use and cannot be unloaded";
    case ERROR_PRINTER_DRIVER_ALREADY_INSTALLED                                   : return "The specified printer driver is already installed";
    case ERROR_UNKNOWN_PORT                                                       : return "The specified port is unknown";
    case ERROR_UNKNOWN_PRINTER_DRIVER                                             : return "The printer driver is unknown";
    case ERROR_UNKNOWN_PRINTPROCESSOR                                             : return "The print processor is unknown";
    case ERROR_INVALID_SEPARATOR_FILE                                             : return "The specified separator file is invalid";
    case ERROR_INVALID_PRIORITY                                                   : return "The specified priority is invalid";
    case ERROR_INVALID_PRINTER_NAME                                               : return "The printer name is invalid";
    case ERROR_PRINTER_ALREADY_EXISTS                                             : return "The printer already exists";
    case ERROR_INVALID_PRINTER_COMMAND                                            : return "The printer command is invalid";
    case ERROR_INVALID_DATATYPE                                                   : return "The specified datatype is invalid";
    case ERROR_INVALID_ENVIRONMENT                                                : return "The environment specified is invalid";
    case RPC_S_NO_MORE_BINDINGS                                                   : return "There are no more bindings";
    case ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT                                  : return "The account used is an interdomain trust account. Use your global user account or local user account to access this server";
    case ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT                                  : return "The account used is a computer account. Use your global user account or local user account to access this server";
    case ERROR_NOLOGON_SERVER_TRUST_ACCOUNT                                       : return "The account used is a server trust account. Use your global user account or local user account to access this server";
    case ERROR_DOMAIN_TRUST_INCONSISTENT                                          : return "The name or security ID (SID) of the domain specified is inconsistent with the trust information for that domain";
    case ERROR_SERVER_HAS_OPEN_HANDLES                                            : return "The server is in use and cannot be unloaded";
    case ERROR_RESOURCE_DATA_NOT_FOUND                                            : return "The specified image file did not contain a resource section";
    case ERROR_RESOURCE_TYPE_NOT_FOUND                                            : return "The specified resource type cannot be found in the image file";
    case ERROR_RESOURCE_NAME_NOT_FOUND                                            : return "The specified resource name cannot be found in the image file";
    case ERROR_RESOURCE_LANG_NOT_FOUND                                            : return "The specified resource language ID cannot be found in the image file";
    case ERROR_NOT_ENOUGH_QUOTA                                                   : return "Not enough quota is available to process this command";
    case RPC_S_NO_INTERFACES                                                      : return "No interfaces have been registered";
    case RPC_S_CALL_CANCELLED                                                     : return "The remote procedure call was cancelled";
    case RPC_S_BINDING_INCOMPLETE                                                 : return "The binding handle does not contain all required information";
    case RPC_S_COMM_FAILURE                                                       : return "A communications failure occurred during a remote procedure call";
    case RPC_S_UNSUPPORTED_AUTHN_LEVEL                                            : return "The requested authentication level is not supported";
    case RPC_S_NO_PRINC_NAME                                                      : return "No principal name registered";
    case RPC_S_NOT_RPC_ERROR                                                      : return "The error specified is not a valid Windows RPC error code";
    case RPC_S_UUID_LOCAL_ONLY                                                    : return "A UUID that is valid only on this computer has been allocated";
    case RPC_S_SEC_PKG_ERROR                                                      : return "A security package specific error occurred";
    case RPC_S_NOT_CANCELLED                                                      : return "Thread is not canceled";
    case RPC_X_INVALID_ES_ACTION                                                  : return "Invalid operation on the encoding/decoding handle";
    case RPC_X_WRONG_ES_VERSION                                                   : return "Incompatible version of the serializing package";
    case RPC_X_WRONG_STUB_VERSION                                                 : return "Incompatible version of the RPC stub";
    case RPC_X_INVALID_PIPE_OBJECT                                                : return "The RPC pipe object is invalid or corrupted";
    case RPC_X_WRONG_PIPE_ORDER                                                   : return "An invalid operation was attempted on an RPC pipe object";
    case RPC_X_WRONG_PIPE_VERSION                                                 : return "Unsupported RPC pipe version";
    case RPC_S_COOKIE_AUTH_FAILED                                                 : return "HTTP proxy server rejected the connection because the cookie authentication failed";
    case RPC_S_DO_NOT_DISTURB                                                     : return "The RPC server is suspended, and could not be resumed for this request. The call did not execute";
    case RPC_S_SYSTEM_HANDLE_COUNT_EXCEEDED                                       : return "The RPC call contains too many handles to be transmitted in a single request";
    case RPC_S_SYSTEM_HANDLE_TYPE_MISMATCH                                        : return "The RPC call contains a handle that differs from the declared handle type";
    case RPC_S_GROUP_MEMBER_NOT_FOUND                                             : return "The group member was not found";
    case EPT_S_CANT_CREATE                                                        : return "The endpoint mapper database entry could not be created";
    case RPC_S_INVALID_OBJECT                                                     : return "The object universal unique identifier (UUID) is the nil UUID";
    case ERROR_INVALID_TIME                                                       : return "The specified time is invalid";
    case ERROR_INVALID_FORM_NAME                                                  : return "The specified form name is invalid";
    case ERROR_INVALID_FORM_SIZE                                                  : return "The specified form size is invalid";
    case ERROR_ALREADY_WAITING                                                    : return "The specified printer handle is already being waited on";
    case ERROR_PRINTER_DELETED                                                    : return "The specified printer has been deleted";
    case ERROR_INVALID_PRINTER_STATE                                              : return "The state of the printer is invalid";
    case ERROR_PASSWORD_MUST_CHANGE                                               : return "The user's password must be changed before signing in";
    case ERROR_DOMAIN_CONTROLLER_NOT_FOUND                                        : return "Could not find the domain controller for this domain";
    case ERROR_ACCOUNT_LOCKED_OUT                                                 : return "The referenced account is currently locked out and may not be logged on to";
    case OR_INVALID_OXID                                                          : return "The object exporter specified was not found";
    case OR_INVALID_OID                                                           : return "The object specified was not found";
    case OR_INVALID_SET                                                           : return "The object resolver set specified was not found";
    case RPC_S_SEND_INCOMPLETE                                                    : return "Some data remains to be sent in the request buffer";
    case RPC_S_INVALID_ASYNC_HANDLE                                               : return "Invalid asynchronous remote procedure call handle";
    case RPC_S_INVALID_ASYNC_CALL                                                 : return "Invalid asynchronous RPC call handle for this operation";
    case RPC_X_PIPE_CLOSED                                                        : return "The RPC pipe object has already been closed";
    case RPC_X_PIPE_DISCIPLINE_ERROR                                              : return "The RPC call completed before all pipes were processed";
    case RPC_X_PIPE_EMPTY                                                         : return "No more data is available from the RPC pipe";
    case ERROR_NO_SITENAME                                                        : return "No site name is available for this machine";
    case ERROR_CANT_ACCESS_FILE                                                   : return "The file cannot be accessed by the system";
    case ERROR_CANT_RESOLVE_FILENAME                                              : return "The name of the file cannot be resolved by the system";
    case RPC_S_ENTRY_TYPE_MISMATCH                                                : return "The entry is not of the expected type";
    case RPC_S_NOT_ALL_OBJS_EXPORTED                                              : return "Not all object UUIDs could be exported to the specified entry";
    case RPC_S_INTERFACE_NOT_EXPORTED                                             : return "Interface could not be exported to the specified entry";
    case RPC_S_PROFILE_NOT_ADDED                                                  : return "The specified profile entry could not be added";
    case RPC_S_PRF_ELT_NOT_ADDED                                                  : return "The specified profile element could not be added";
    case RPC_S_PRF_ELT_NOT_REMOVED                                                : return "The specified profile element could not be removed";
    case RPC_S_GRP_ELT_NOT_ADDED                                                  : return "The group element could not be added";
    case RPC_S_GRP_ELT_NOT_REMOVED                                                : return "The group element could not be removed";
    case ERROR_KM_DRIVER_BLOCKED                                                  : return "The printer driver is not compatible with a policy enabled on your computer that blocks NT 4.0 drivers";
    case ERROR_CONTEXT_EXPIRED                                                    : return "The context has expired and can no longer be used";
    case ERROR_PER_USER_TRUST_QUOTA_EXCEEDED                                      : return "The current user's delegated trust creation quota has been exceeded";
    case ERROR_ALL_USER_TRUST_QUOTA_EXCEEDED                                      : return "The total delegated trust creation quota has been exceeded";
    case ERROR_USER_DELETE_TRUST_QUOTA_EXCEEDED                                   : return "The current user's delegated trust deletion quota has been exceeded";
    case ERROR_AUTHENTICATION_FIREWALL_FAILED                                     : return "The computer you are signing into is protected by an authentication firewall. The specified account is not allowed to authenticate to the computer";
    case ERROR_REMOTE_PRINT_CONNECTIONS_BLOCKED                                   : return "Remote connections to the Print Spooler are blocked by a policy set on your machine";
    case ERROR_NTLM_BLOCKED                                                       : return "Authentication failed because NTLM authentication has been disabled";
    case ERROR_PASSWORD_CHANGE_REQUIRED                                           : return "Logon Failure: EAS policy requires that the user change their password before this operation can be performed";
    case ERROR_LOST_MODE_LOGON_RESTRICTION                                        : return "An administrator has restricted sign in. To sign in, make sure your device is connected to the Internet, and have your administrator sign in first";
    case ERROR_INVALID_PIXEL_FORMAT                                               : return "The pixel format is invalid";
    case ERROR_BAD_DRIVER                                                         : return "The specified driver is invalid";
    case ERROR_INVALID_WINDOW_STYLE                                               : return "The window style or class attribute is invalid for this operation";
    case ERROR_METAFILE_NOT_SUPPORTED                                             : return "The requested metafile operation is not supported";
    case ERROR_TRANSFORM_NOT_SUPPORTED                                            : return "The requested transformation operation is not supported";
    case ERROR_CLIPPING_NOT_SUPPORTED                                             : return "The requested clipping operation is not supported";
    case ERROR_INVALID_CMM                                                        : return "The specified color management module is invalid";
    case ERROR_INVALID_PROFILE                                                    : return "The specified color profile is invalid";
    case ERROR_TAG_NOT_FOUND                                                      : return "The specified tag was not found";
    case ERROR_TAG_NOT_PRESENT                                                    : return "A required tag is not present";
    case ERROR_DUPLICATE_TAG                                                      : return "The specified tag is already present";
    case ERROR_PROFILE_NOT_ASSOCIATED_WITH_DEVICE                                 : return "The specified color profile is not associated with the specified device";
    case ERROR_PROFILE_NOT_FOUND                                                  : return "The specified color profile was not found";
    case ERROR_INVALID_COLORSPACE                                                 : return "The specified color space is invalid";
    case ERROR_ICM_NOT_ENABLED                                                    : return "Image Color Management is not enabled";
    case ERROR_DELETING_ICM_XFORM                                                 : return "There was an error while deleting the color transform";
    case ERROR_INVALID_TRANSFORM                                                  : return "The specified color transform is invalid";
    case ERROR_COLORSPACE_MISMATCH                                                : return "The specified transform does not match the bitmap's color space";
    case ERROR_INVALID_COLORINDEX                                                 : return "The specified named color index is not present in the profile";
    case ERROR_PROFILE_DOES_NOT_MATCH_DEVICE                                      : return "The specified profile is intended for a device of a different type than the specified device";
    case ERROR_CONNECTED_OTHER_PASSWORD                                           : return "The network connection was made successfully, but the user had to be prompted for a password other than the one originally specified";
    case ERROR_CONNECTED_OTHER_PASSWORD_DEFAULT                                   : return "The network connection was made successfully using default credentials";
    case ERROR_BAD_USERNAME                                                       : return "The specified username is invalid";
    case ERROR_NOT_CONNECTED                                                      : return "This network connection does not exist";
    case ERROR_OPEN_FILES                                                         : return "This network connection has files open or requests pending";
    case ERROR_ACTIVE_CONNECTIONS                                                 : return "Active connections still exist";
    case ERROR_DEVICE_IN_USE                                                      : return "The device is in use by an active process and cannot be disconnected";
    case ERROR_UNKNOWN_PRINT_MONITOR                                              : return "The specified print monitor is unknown";
    case ERROR_PRINTER_DRIVER_IN_USE                                              : return "The specified printer driver is currently in use";
    case ERROR_SPOOL_FILE_NOT_FOUND                                               : return "The spool file was not found";
    case ERROR_SPL_NO_STARTDOC                                                    : return "A StartDocPrinter call was not issued";
    case ERROR_SPL_NO_ADDJOB                                                      : return "An AddJob call was not issued";
    case ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED                                  : return "The specified print processor has already been installed";
    case ERROR_PRINT_MONITOR_ALREADY_INSTALLED                                    : return "The specified print monitor has already been installed";
    case ERROR_INVALID_PRINT_MONITOR                                              : return "The specified print monitor does not have the required functions";
    case ERROR_PRINT_MONITOR_IN_USE                                               : return "The specified print monitor is currently in use";
    case ERROR_PRINTER_HAS_JOBS_QUEUED                                            : return "The requested operation is not allowed when there are jobs queued to the printer";
    case ERROR_SUCCESS_REBOOT_REQUIRED                                            : return "The requested operation is successful. Changes will not be effective until the system is rebooted";
    case ERROR_SUCCESS_RESTART_REQUIRED                                           : return "The requested operation is successful. Changes will not be effective until the service is restarted";
    case ERROR_PRINTER_NOT_FOUND                                                  : return "No printers were found";
    case ERROR_PRINTER_DRIVER_WARNED                                              : return "The printer driver is known to be unreliable";
    case ERROR_PRINTER_DRIVER_BLOCKED                                             : return "The printer driver is known to harm the system";
    case ERROR_PRINTER_DRIVER_PACKAGE_IN_USE                                      : return "The specified printer driver package is currently in use";
    case ERROR_CORE_DRIVER_PACKAGE_NOT_FOUND                                      : return "Unable to find a core driver package that is required by the printer driver package";
    case ERROR_FAIL_REBOOT_REQUIRED                                               : return "The requested operation failed. A system reboot is required to roll back changes made";
    case ERROR_FAIL_REBOOT_INITIATED                                              : return "The requested operation failed. A system reboot has been initiated to roll back changes made";
    case ERROR_PRINTER_DRIVER_DOWNLOAD_NEEDED                                     : return "The specified printer driver was not found on the system and needs to be downloaded";
    case ERROR_PRINT_JOB_RESTART_REQUIRED                                         : return "The requested print job has failed to print. A print system update requires the job to be resubmitted";
    case ERROR_INVALID_PRINTER_DRIVER_MANIFEST                                    : return "The printer driver does not contain a valid manifest, or contains too many manifests";
    case ERROR_PRINTER_NOT_SHAREABLE                                              : return "The specified printer cannot be shared";
    case ERROR_REQUEST_PAUSED                                                     : return "The operation was paused";
    case ERROR_IO_REISSUE_AS_CACHED                                               : return "Reissue the given operation as a cached IO operation";
    case ERROR_WINS_INTERNAL                                                      : return "WINS encountered an error while processing the command";
    case ERROR_CAN_NOT_DEL_LOCAL_WINS                                             : return "The local WINS cannot be deleted";
    case ERROR_STATIC_INIT                                                        : return "The importation from the file failed";
    case ERROR_INC_BACKUP                                                         : return "The backup failed. Was a full backup done before?";
    case ERROR_FULL_BACKUP                                                        : return "The backup failed. Check the directory to which you are backing the database";
    case ERROR_REC_NON_EXISTENT                                                   : return "The name does not exist in the WINS database";
    case ERROR_RPL_NOT_ALLOWED                                                    : return "Replication with a nonconfigured partner is not allowed";
    case PEERDIST_ERROR_CONTENTINFO_VERSION_UNSUPPORTED                           : return "The version of the supplied content information is not supported";
    case PEERDIST_ERROR_CANNOT_PARSE_CONTENTINFO                                  : return "The supplied content information is malformed";
    case PEERDIST_ERROR_MISSING_DATA                                              : return "The requested data cannot be found in local or peer caches";
    case PEERDIST_ERROR_NO_MORE                                                   : return "No more data is available or required";
    case PEERDIST_ERROR_NOT_INITIALIZED                                           : return "The supplied object has not been initialized";
    case PEERDIST_ERROR_ALREADY_INITIALIZED                                       : return "The supplied object has already been initialized";
    case PEERDIST_ERROR_SHUTDOWN_IN_PROGRESS                                      : return "A shutdown operation is already in progress";
    case PEERDIST_ERROR_INVALIDATED                                               : return "The supplied object has already been invalidated";
    case PEERDIST_ERROR_ALREADY_EXISTS                                            : return "An element already exists and was not replaced";
    case PEERDIST_ERROR_OPERATION_NOTFOUND                                        : return "Can not cancel the requested operation as it has already been completed";
    case PEERDIST_ERROR_ALREADY_COMPLETED                                         : return "Can not perform the reqested operation because it has already been carried out";
    case PEERDIST_ERROR_OUT_OF_BOUNDS                                             : return "An operation accessed data beyond the bounds of valid data";
    case PEERDIST_ERROR_VERSION_UNSUPPORTED                                       : return "The requested version is not supported";
    case PEERDIST_ERROR_INVALID_CONFIGURATION                                     : return "A configuration value is invalid";
    case PEERDIST_ERROR_NOT_LICENSED                                              : return "The SKU is not licensed";
    case PEERDIST_ERROR_SERVICE_UNAVAILABLE                                       : return "PeerDist Service is still initializing and will be available shortly";
    case PEERDIST_ERROR_TRUST_FAILURE                                             : return "Communication with one or more computers will be temporarily blocked due to recent errors";
    case ERROR_DHCP_ADDRESS_CONFLICT                                              : return "The DHCP client has obtained an IP address that is already in use on the network. The local interface will be disabled until the DHCP client can obtain a new address";
    case ERROR_WMI_GUID_NOT_FOUND                                                 : return "The GUID passed was not recognized as valid by a WMI data provider";
    case ERROR_WMI_INSTANCE_NOT_FOUND                                             : return "The instance name passed was not recognized as valid by a WMI data provider";
    case ERROR_WMI_ITEMID_NOT_FOUND                                               : return "The data item ID passed was not recognized as valid by a WMI data provider";
    case ERROR_WMI_TRY_AGAIN                                                      : return "The WMI request could not be completed and should be retried";
    case ERROR_WMI_DP_NOT_FOUND                                                   : return "The WMI data provider could not be located";
    case ERROR_WMI_UNRESOLVED_INSTANCE_REF                                        : return "The WMI data provider references an instance set that has not been registered";
    case ERROR_WMI_ALREADY_ENABLED                                                : return "The WMI data block or event notification has already been enabled";
    case ERROR_WMI_GUID_DISCONNECTED                                              : return "The WMI data block is no longer available";
    case ERROR_WMI_SERVER_UNAVAILABLE                                             : return "The WMI data service is not available";
    case ERROR_WMI_DP_FAILED                                                      : return "The WMI data provider failed to carry out the request";
    case ERROR_WMI_INVALID_MOF                                                    : return "The WMI MOF information is not valid";
    case ERROR_WMI_INVALID_REGINFO                                                : return "The WMI registration information is not valid";
    case ERROR_WMI_ALREADY_DISABLED                                               : return "The WMI data block or event notification has already been disabled";
    case ERROR_WMI_READ_ONLY                                                      : return "The WMI data item or data block is read only";
    case ERROR_WMI_SET_FAILURE                                                    : return "The WMI data item or data block could not be changed";
    case ERROR_NOT_APPCONTAINER                                                   : return "This operation is only valid in the context of an app container";
    case ERROR_APPCONTAINER_REQUIRED                                              : return "This application can only run in the context of an app container";
    case ERROR_NOT_SUPPORTED_IN_APPCONTAINER                                      : return "This functionality is not supported in the context of an app container";
    case ERROR_INVALID_PACKAGE_SID_LENGTH                                         : return "The length of the SID supplied is not a valid length for app container SIDs";
    case ERROR_INVALID_MEDIA                                                      : return "The media identifier does not represent a valid medium";
    case ERROR_INVALID_LIBRARY                                                    : return "The library identifier does not represent a valid library";
    case ERROR_INVALID_MEDIA_POOL                                                 : return "The media pool identifier does not represent a valid media pool";
    case ERROR_DRIVE_MEDIA_MISMATCH                                               : return "The drive and medium are not compatible or exist in different libraries";
    case ERROR_MEDIA_OFFLINE                                                      : return "The medium currently exists in an offline library and must be online to perform this operation";
    case ERROR_LIBRARY_OFFLINE                                                    : return "The operation cannot be performed on an offline library";
    case ERROR_EMPTY                                                              : return "The library, drive, or media pool is empty";
    case ERROR_NOT_EMPTY                                                          : return "The library, drive, or media pool must be empty to perform this operation";
    case ERROR_MEDIA_UNAVAILABLE                                                  : return "No media is currently available in this media pool or library";
    case ERROR_RESOURCE_DISABLED                                                  : return "A resource required for this operation is disabled";
    case ERROR_INVALID_CLEANER                                                    : return "The media identifier does not represent a valid cleaner";
    case ERROR_UNABLE_TO_CLEAN                                                    : return "The drive cannot be cleaned or does not support cleaning";
    case ERROR_OBJECT_NOT_FOUND                                                   : return "The object identifier does not represent a valid object";
    case ERROR_DATABASE_FAILURE                                                   : return "Unable to read from or write to the database";
    case ERROR_DATABASE_FULL                                                      : return "The database is full";
    case ERROR_MEDIA_INCOMPATIBLE                                                 : return "The medium is not compatible with the device or media pool";
    case ERROR_RESOURCE_NOT_PRESENT                                               : return "The resource required for this operation does not exist";
    case ERROR_INVALID_OPERATION                                                  : return "The operation identifier is not valid";
    case ERROR_MEDIA_NOT_AVAILABLE                                                : return "The media is not mounted or ready for use";
    case ERROR_DEVICE_NOT_AVAILABLE                                               : return "The device is not ready for use";
    case ERROR_REQUEST_REFUSED                                                    : return "The operator or administrator has refused the request";
    case ERROR_INVALID_DRIVE_OBJECT                                               : return "The drive identifier does not represent a valid drive";
    case ERROR_LIBRARY_FULL                                                       : return "Library is full. No slot is available for use";
    case ERROR_MEDIUM_NOT_ACCESSIBLE                                              : return "The transport cannot access the medium";
    case ERROR_UNABLE_TO_LOAD_MEDIUM                                              : return "Unable to load the medium into the drive";
    case ERROR_UNABLE_TO_INVENTORY_DRIVE                                          : return "Unable to retrieve the drive status";
    case ERROR_UNABLE_TO_INVENTORY_SLOT                                           : return "Unable to retrieve the slot status";
    case ERROR_UNABLE_TO_INVENTORY_TRANSPORT                                      : return "Unable to retrieve status about the transport";
    case ERROR_TRANSPORT_FULL                                                     : return "Cannot use the transport because it is already in use";
    case ERROR_CONTROLLING_IEPORT                                                 : return "Unable to open or close the inject/eject port";
    case ERROR_UNABLE_TO_EJECT_MOUNTED_MEDIA                                      : return "Unable to eject the medium because it is in a drive";
    case ERROR_CLEANER_SLOT_SET                                                   : return "A cleaner slot is already reserved";
    case ERROR_CLEANER_SLOT_NOT_SET                                               : return "A cleaner slot is not reserved";
    case ERROR_CLEANER_CARTRIDGE_SPENT                                            : return "The cleaner cartridge has performed the maximum number of drive cleanings";
    case ERROR_UNEXPECTED_OMID                                                    : return "Unexpected on-medium identifier";
    case ERROR_CANT_DELETE_LAST_ITEM                                              : return "The last remaining item in this group or resource cannot be deleted";
    case ERROR_MESSAGE_EXCEEDS_MAX_SIZE                                           : return "The message provided exceeds the maximum size allowed for this parameter";
    case ERROR_VOLUME_CONTAINS_SYS_FILES                                          : return "The volume contains system or paging files";
    case ERROR_INDIGENOUS_TYPE                                                    : return "The media type cannot be removed from this library since at least one drive in the library reports it can support this media type";
    case ERROR_NO_SUPPORTING_DRIVES                                               : return "This offline media cannot be mounted on this system since no enabled drives are present which can be used";
    case ERROR_CLEANER_CARTRIDGE_INSTALLED                                        : return "A cleaner cartridge is present in the tape library";
    case ERROR_IEPORT_FULL                                                        : return "Cannot use the inject/eject port because it is not empty";
    case ERROR_FILE_OFFLINE                                                       : return "This file is currently not available for use on this computer";
    case ERROR_REMOTE_STORAGE_NOT_ACTIVE                                          : return "The remote storage service is not operational at this time";
    case ERROR_REMOTE_STORAGE_MEDIA_ERROR                                         : return "The remote storage service encountered a media error";
    case ERROR_NOT_A_REPARSE_POINT                                                : return "The file or directory is not a reparse point";
    case ERROR_REPARSE_ATTRIBUTE_CONFLICT                                         : return "The reparse point attribute cannot be set because it conflicts with an existing attribute";
    case ERROR_INVALID_REPARSE_DATA                                               : return "The data present in the reparse point buffer is invalid";
    case ERROR_REPARSE_TAG_INVALID                                                : return "The tag present in the reparse point buffer is invalid";
    case ERROR_REPARSE_TAG_MISMATCH                                               : return "There is a mismatch between the tag specified in the request and the tag present in the reparse point";
    case ERROR_REPARSE_POINT_ENCOUNTERED                                          : return "The object manager encountered a reparse point while retrieving an object";
    case ERROR_APP_DATA_NOT_FOUND                                                 : return "Fast Cache data not found";
    case ERROR_APP_DATA_EXPIRED                                                   : return "Fast Cache data expired";
    case ERROR_APP_DATA_CORRUPT                                                   : return "Fast Cache data corrupt";
    case ERROR_APP_DATA_LIMIT_EXCEEDED                                            : return "Fast Cache data has exceeded its max size and cannot be updated";
    case ERROR_APP_DATA_REBOOT_REQUIRED                                           : return "Fast Cache has been ReArmed and requires a reboot until it can be updated";
    case ERROR_SECUREBOOT_ROLLBACK_DETECTED                                       : return "Secure Boot detected that rollback of protected data has been attempted";
    case ERROR_SECUREBOOT_POLICY_VIOLATION                                        : return "The value is protected by Secure Boot policy and cannot be modified or deleted";
    case ERROR_SECUREBOOT_INVALID_POLICY                                          : return "The Secure Boot policy is invalid";
    case ERROR_SECUREBOOT_POLICY_PUBLISHER_NOT_FOUND                              : return "A new Secure Boot policy did not contain the current publisher on its update list";
    case ERROR_SECUREBOOT_POLICY_NOT_SIGNED                                       : return "The Secure Boot policy is either not signed or is signed by a non-trusted signer";
    case ERROR_SECUREBOOT_NOT_ENABLED                                             : return "Secure Boot is not enabled on this machine";
    case ERROR_SECUREBOOT_FILE_REPLACED                                           : return "Secure Boot requires that certain files and drivers are not replaced by other files or drivers";
    case ERROR_SECUREBOOT_POLICY_NOT_AUTHORIZED                                   : return "The Secure Boot Supplemental Policy file was not authorized on this machine";
    case ERROR_SECUREBOOT_POLICY_UNKNOWN                                          : return "The Supplemntal Policy is not recognized on this device";
    case ERROR_SECUREBOOT_POLICY_MISSING_ANTIROLLBACKVERSION                      : return "The Antirollback version was not found in the Secure Boot Policy";
    case ERROR_SECUREBOOT_PLATFORM_ID_MISMATCH                                    : return "The Platform ID specified in the Secure Boot policy does not match the Platform ID on this device";
    case ERROR_SECUREBOOT_POLICY_ROLLBACK_DETECTED                                : return "The Secure Boot policy file has an older Antirollback Version than this device";
    case ERROR_SECUREBOOT_POLICY_UPGRADE_MISMATCH                                 : return "The Secure Boot policy file does not match the upgraded legacy policy";
    case ERROR_SECUREBOOT_REQUIRED_POLICY_FILE_MISSING                            : return "The Secure Boot policy file is required but could not be found";
    case ERROR_SECUREBOOT_NOT_BASE_POLICY                                         : return "Supplemental Secure Boot policy file can not be loaded as a base Secure Boot policy";
    case ERROR_SECUREBOOT_NOT_SUPPLEMENTAL_POLICY                                 : return "Base Secure Boot policy file can not be loaded as a Supplemental Secure Boot policy";
    case ERROR_OFFLOAD_READ_FLT_NOT_SUPPORTED                                     : return "The copy offload read operation is not supported by a filter";
    case ERROR_OFFLOAD_WRITE_FLT_NOT_SUPPORTED                                    : return "The copy offload write operation is not supported by a filter";
    case ERROR_OFFLOAD_READ_FILE_NOT_SUPPORTED                                    : return "The copy offload read operation is not supported for the file";
    case ERROR_OFFLOAD_WRITE_FILE_NOT_SUPPORTED                                   : return "The copy offload write operation is not supported for the file";
    case ERROR_ALREADY_HAS_STREAM_ID                                              : return "This file is currently associated with a different stream id";
    case ERROR_SMR_GARBAGE_COLLECTION_REQUIRED                                    : return "The volume must undergo garbage collection";
    case ERROR_VOLUME_NOT_SIS_ENABLED                                             : return "Single Instance Storage is not available on this volume";
    case ERROR_SYSTEM_INTEGRITY_ROLLBACK_DETECTED                                 : return "System Integrity detected that policy rollback has been attempted";
    case ERROR_SYSTEM_INTEGRITY_POLICY_VIOLATION                                  : return "Your organization used Device Guard to block this app. Contact your support person for more info";
    case ERROR_SYSTEM_INTEGRITY_INVALID_POLICY                                    : return "The System Integrity policy is invalid";
    case ERROR_SYSTEM_INTEGRITY_POLICY_NOT_SIGNED                                 : return "The System Integrity policy is either not signed or is signed by a non-trusted signer";
    case ERROR_VSM_NOT_INITIALIZED                                                : return "Virtual Secure Mode (VSM) is not initialized. The hypervisor or VSM may not be present or enabled";
    case ERROR_VSM_DMA_PROTECTION_NOT_IN_USE                                      : return "The hypervisor is not protecting DMA because an IOMMU is not present or not enabled in the BIOS";
    case ERROR_PLATFORM_MANIFEST_NOT_AUTHORIZED                                   : return "The Platform Manifest file was not authorized on this machine";
    case ERROR_PLATFORM_MANIFEST_INVALID                                          : return "The Platform Manifest file was not valid";
    case ERROR_PLATFORM_MANIFEST_FILE_NOT_AUTHORIZED                              : return "The file is not authorized on this platform because an entry was not found in the Platform Manifest";
    case ERROR_PLATFORM_MANIFEST_CATALOG_NOT_AUTHORIZED                           : return "The catalog is not authorized on this platform because an entry was not found in the Platform Manifest";
    case ERROR_PLATFORM_MANIFEST_BINARY_ID_NOT_FOUND                              : return "The file is not authorized on this platform because a Binary ID was not found in the embedded signature";
    case ERROR_PLATFORM_MANIFEST_NOT_ACTIVE                                       : return "No active Platform Manifest exists on this system";
    case ERROR_PLATFORM_MANIFEST_NOT_SIGNED                                       : return "The Platform Manifest file was not properly signed";
    case ERROR_DEPENDENT_RESOURCE_EXISTS                                          : return "The operation cannot be completed because other resources are dependent on this resource";
    case ERROR_DEPENDENCY_NOT_FOUND                                               : return "The cluster resource dependency cannot be found";
    case ERROR_DEPENDENCY_ALREADY_EXISTS                                          : return "The cluster resource cannot be made dependent on the specified resource because it is already dependent";
    case ERROR_RESOURCE_NOT_ONLINE                                                : return "The cluster resource is not online";
    case ERROR_HOST_NODE_NOT_AVAILABLE                                            : return "A cluster node is not available for this operation";
    case ERROR_RESOURCE_NOT_AVAILABLE                                             : return "The cluster resource is not available";
    case ERROR_RESOURCE_NOT_FOUND                                                 : return "The cluster resource could not be found";
    case ERROR_SHUTDOWN_CLUSTER                                                   : return "The cluster is being shut down";
    case ERROR_CANT_EVICT_ACTIVE_NODE                                             : return "A cluster node cannot be evicted from the cluster unless the node is down or it is the last node";
    case ERROR_OBJECT_ALREADY_EXISTS                                              : return "The object already exists";
    case ERROR_OBJECT_IN_LIST                                                     : return "The object is already in the list";
    case ERROR_GROUP_NOT_AVAILABLE                                                : return "The cluster group is not available for any new requests";
    case ERROR_GROUP_NOT_FOUND                                                    : return "The cluster group could not be found";
    case ERROR_GROUP_NOT_ONLINE                                                   : return "The operation could not be completed because the cluster group is not online";
    case ERROR_HOST_NODE_NOT_RESOURCE_OWNER                                       : return "The operation failed because either the specified cluster node is not the owner of the resource, or the node is not a possible owner of the resource";
    case ERROR_HOST_NODE_NOT_GROUP_OWNER                                          : return "The operation failed because either the specified cluster node is not the owner of the group, or the node is not a possible owner of the group";
    case ERROR_RESMON_CREATE_FAILED                                               : return "The cluster resource could not be created in the specified resource monitor";
    case ERROR_RESMON_ONLINE_FAILED                                               : return "The cluster resource could not be brought online by the resource monitor";
    case ERROR_RESOURCE_ONLINE                                                    : return "The operation could not be completed because the cluster resource is online";
    case ERROR_QUORUM_RESOURCE                                                    : return "The cluster resource could not be deleted or brought offline because it is the quorum resource";
    case ERROR_NOT_QUORUM_CAPABLE                                                 : return "The cluster could not make the specified resource a quorum resource because it is not capable of being a quorum resource";
    case ERROR_CLUSTER_SHUTTING_DOWN                                              : return "The cluster software is shutting down";
    case ERROR_INVALID_STATE                                                      : return "The group or resource is not in the correct state to perform the requested operation";
    case ERROR_RESOURCE_PROPERTIES_STORED                                         : return "The properties were stored but not all changes will take effect until the next time the resource is brought online";
    case ERROR_NOT_QUORUM_CLASS                                                   : return "The cluster could not make the specified resource a quorum resource because it does not belong to a shared storage class";
    case ERROR_CORE_RESOURCE                                                      : return "The cluster resource could not be deleted since it is a core resource";
    case ERROR_QUORUM_RESOURCE_ONLINE_FAILED                                      : return "The quorum resource failed to come online";
    case ERROR_QUORUMLOG_OPEN_FAILED                                              : return "The quorum log could not be created or mounted successfully";
    case ERROR_CLUSTERLOG_CORRUPT                                                 : return "The cluster log is corrupt";
    case ERROR_CLUSTERLOG_RECORD_EXCEEDS_MAXSIZE                                  : return "The record could not be written to the cluster log since it exceeds the maximum size";
    case ERROR_CLUSTERLOG_EXCEEDS_MAXSIZE                                         : return "The cluster log exceeds its maximum size";
    case ERROR_CLUSTERLOG_CHKPOINT_NOT_FOUND                                      : return "No checkpoint record was found in the cluster log";
    case ERROR_CLUSTERLOG_NOT_ENOUGH_SPACE                                        : return "The minimum required disk space needed for logging is not available";
    case ERROR_QUORUM_OWNER_ALIVE                                                 : return "The cluster node failed to take control of the quorum resource because the resource is owned by another active node";
    case ERROR_NETWORK_NOT_AVAILABLE                                              : return "A cluster network is not available for this operation";
    case ERROR_NODE_NOT_AVAILABLE                                                 : return "A cluster node is not available for this operation";
    case ERROR_ALL_NODES_NOT_AVAILABLE                                            : return "All cluster nodes must be running to perform this operation";
    case ERROR_RESOURCE_FAILED                                                    : return "A cluster resource failed";
    case ERROR_CLUSTER_INVALID_NODE                                               : return "The cluster node is not valid";
    case ERROR_CLUSTER_NODE_EXISTS                                                : return "The cluster node already exists";
    case ERROR_CLUSTER_JOIN_IN_PROGRESS                                           : return "A node is in the process of joining the cluster";
    case ERROR_CLUSTER_NODE_NOT_FOUND                                             : return "The cluster node was not found";
    case ERROR_CLUSTER_LOCAL_NODE_NOT_FOUND                                       : return "The cluster local node information was not found";
    case ERROR_CLUSTER_NETWORK_EXISTS                                             : return "The cluster network already exists";
    case ERROR_CLUSTER_NETWORK_NOT_FOUND                                          : return "The cluster network was not found";
    case ERROR_CLUSTER_NETINTERFACE_EXISTS                                        : return "The cluster network interface already exists";
    case ERROR_CLUSTER_NETINTERFACE_NOT_FOUND                                     : return "The cluster network interface was not found";
    case ERROR_CLUSTER_INVALID_REQUEST                                            : return "The cluster request is not valid for this object";
    case ERROR_CLUSTER_INVALID_NETWORK_PROVIDER                                   : return "The cluster network provider is not valid";
    case ERROR_CLUSTER_NODE_DOWN                                                  : return "The cluster node is down";
    case ERROR_CLUSTER_NODE_UNREACHABLE                                           : return "The cluster node is not reachable";
    case ERROR_CLUSTER_NODE_NOT_MEMBER                                            : return "The cluster node is not a member of the cluster";
    case ERROR_CLUSTER_JOIN_NOT_IN_PROGRESS                                       : return "A cluster join operation is not in progress";
    case ERROR_CLUSTER_INVALID_NETWORK                                            : return "The cluster network is not valid";
    case ERROR_CLUSTER_NODE_UP                                                    : return "The cluster node is up";
    case ERROR_CLUSTER_IPADDR_IN_USE                                              : return "The cluster IP address is already in use";
    case ERROR_CLUSTER_NODE_NOT_PAUSED                                            : return "The cluster node is not paused";
    case ERROR_CLUSTER_NO_SECURITY_CONTEXT                                        : return "No cluster security context is available";
    case ERROR_CLUSTER_NETWORK_NOT_INTERNAL                                       : return "The cluster network is not configured for internal cluster communication";
    case ERROR_CLUSTER_NODE_ALREADY_UP                                            : return "The cluster node is already up";
    case ERROR_CLUSTER_NODE_ALREADY_DOWN                                          : return "The cluster node is already down";
    case ERROR_CLUSTER_NETWORK_ALREADY_ONLINE                                     : return "The cluster network is already online";
    case ERROR_CLUSTER_NETWORK_ALREADY_OFFLINE                                    : return "The cluster network is already offline";
    case ERROR_CLUSTER_NODE_ALREADY_MEMBER                                        : return "The cluster node is already a member of the cluster";
    case ERROR_CLUSTER_LAST_INTERNAL_NETWORK                                      : return "The cluster network is the only one configured for internal cluster communication between two or more active cluster nodes. The internal communication capability cannot be removed from the network";
    case ERROR_CLUSTER_NETWORK_HAS_DEPENDENTS                                     : return "One or more cluster resources depend on the network to provide service to clients. The client access capability cannot be removed from the network";
    case ERROR_INVALID_OPERATION_ON_QUORUM                                        : return "This operation cannot currently be performed on the cluster group containing the quorum resource";
    case ERROR_DEPENDENCY_NOT_ALLOWED                                             : return "The cluster quorum resource is not allowed to have any dependencies";
    case ERROR_CLUSTER_NODE_PAUSED                                                : return "The cluster node is paused";
    case ERROR_NODE_CANT_HOST_RESOURCE                                            : return "The cluster resource cannot be brought online. The owner node cannot run this resource";
    case ERROR_CLUSTER_NODE_NOT_READY                                             : return "The cluster node is not ready to perform the requested operation";
    case ERROR_CLUSTER_NODE_SHUTTING_DOWN                                         : return "The cluster node is shutting down";
    case ERROR_CLUSTER_JOIN_ABORTED                                               : return "The cluster join operation was aborted";
    case ERROR_CLUSTER_INCOMPATIBLE_VERSIONS                                      : return "The node failed to join the cluster because the joining node and other nodes in the cluster have incompatible operating system versions. To get more information about operating system versions of the cluster, run the Validate a Configuration Wizard or the Test-Cluster Windows PowerShell cmdlet";
    case ERROR_CLUSTER_MAXNUM_OF_RESOURCES_EXCEEDED                               : return "This resource cannot be created because the cluster has reached the limit on the number of resources it can monitor";
    case ERROR_CLUSTER_SYSTEM_CONFIG_CHANGED                                      : return "The system configuration changed during the cluster join or form operation. The join or form operation was aborted";
    case ERROR_CLUSTER_RESOURCE_TYPE_NOT_FOUND                                    : return "The specified resource type was not found";
    case ERROR_CLUSTER_RESTYPE_NOT_SUPPORTED                                      : return "The specified node does not support a resource of this type. This may be due to version inconsistencies or due to the absence of the resource DLL on this node";
    case ERROR_CLUSTER_RESNAME_NOT_FOUND                                          : return "The specified resource name is not supported by this resource DLL. This may be due to a bad (or changed) name supplied to the resource DLL";
    case ERROR_CLUSTER_NO_RPC_PACKAGES_REGISTERED                                 : return "No authentication package could be registered with the RPC server";
    case ERROR_CLUSTER_OWNER_NOT_IN_PREFLIST                                      : return "You cannot bring the group online because the owner of the group is not in the preferred list for the group. To change the owner node for the group, move the group";
    case ERROR_CLUSTER_DATABASE_SEQMISMATCH                                       : return "The join operation failed because the cluster database sequence number has changed or is incompatible with the locker node. This may happen during a join operation if the cluster database was changing during the join";
    case ERROR_RESMON_INVALID_STATE                                               : return "The resource monitor will not allow the fail operation to be performed while the resource is in its current state. This may happen if the resource is in a pending state";
    case ERROR_CLUSTER_GUM_NOT_LOCKER                                             : return "A non locker code got a request to reserve the lock for making global updates";
    case ERROR_QUORUM_DISK_NOT_FOUND                                              : return "The quorum disk could not be located by the cluster service";
    case ERROR_DATABASE_BACKUP_CORRUPT                                            : return "The backed up cluster database is possibly corrupt";
    case ERROR_CLUSTER_NODE_ALREADY_HAS_DFS_ROOT                                  : return "A DFS root already exists in this cluster node";
    case ERROR_RESOURCE_PROPERTY_UNCHANGEABLE                                     : return "An attempt to modify a resource property failed because it conflicts with another existing property";
    case ERROR_NO_ADMIN_ACCESS_POINT                                              : return "This operation is not supported on a cluster without an Administrator Access Point";
    case ERROR_CLUSTER_MEMBERSHIP_INVALID_STATE                                   : return "An operation was attempted that is incompatible with the current membership state of the node";
    case ERROR_CLUSTER_QUORUMLOG_NOT_FOUND                                        : return "The quorum resource does not contain the quorum log";
    case ERROR_CLUSTER_MEMBERSHIP_HALT                                            : return "The membership engine requested shutdown of the cluster service on this node";
    case ERROR_CLUSTER_INSTANCE_ID_MISMATCH                                       : return "The join operation failed because the cluster instance ID of the joining node does not match the cluster instance ID of the sponsor node";
    case ERROR_CLUSTER_NETWORK_NOT_FOUND_FOR_IP                                   : return "A matching cluster network for the specified IP address could not be found";
    case ERROR_CLUSTER_PROPERTY_DATA_TYPE_MISMATCH                                : return "The actual data type of the property did not match the expected data type of the property";
    case ERROR_CLUSTER_EVICT_WITHOUT_CLEANUP                                      : return "The cluster node was evicted from the cluster successfully, but the node was not cleaned up. To determine what cleanup steps failed and how to recover, see the Failover Clustering application event log using Event Viewer";
    case ERROR_CLUSTER_PARAMETER_MISMATCH                                         : return "Two or more parameter values specified for a resource's properties are in conflict";
    case ERROR_NODE_CANNOT_BE_CLUSTERED                                           : return "This computer cannot be made a member of a cluster";
    case ERROR_CLUSTER_WRONG_OS_VERSION                                           : return "This computer cannot be made a member of a cluster because it does not have the correct version of Windows installed";
    case ERROR_CLUSTER_CANT_CREATE_DUP_CLUSTER_NAME                               : return "A cluster cannot be created with the specified cluster name because that cluster name is already in use. Specify a different name for the cluster";
    case ERROR_CLUSCFG_ALREADY_COMMITTED                                          : return "The cluster configuration action has already been committed";
    case ERROR_CLUSCFG_ROLLBACK_FAILED                                            : return "The cluster configuration action could not be rolled back";
    case ERROR_CLUSCFG_SYSTEM_DISK_DRIVE_LETTER_CONFLICT                          : return "The drive letter assigned to a system disk on one node conflicted with the drive letter assigned to a disk on another node";
    case ERROR_CLUSTER_OLD_VERSION                                                : return "One or more nodes in the cluster are running a version of Windows that does not support this operation";
    case ERROR_CLUSTER_MISMATCHED_COMPUTER_ACCT_NAME                              : return "The name of the corresponding computer account doesn't match the Network Name for this resource";
    case ERROR_CLUSTER_NO_NET_ADAPTERS                                            : return "No network adapters are available";
    case ERROR_CLUSTER_POISONED                                                   : return "The cluster node has been poisoned";
    case ERROR_CLUSTER_GROUP_MOVING                                               : return "The group is unable to accept the request since it is moving to another node";
    case ERROR_CLUSTER_RESOURCE_TYPE_BUSY                                         : return "The resource type cannot accept the request since is too busy performing another operation";
    case ERROR_RESOURCE_CALL_TIMED_OUT                                            : return "The call to the cluster resource DLL timed out";
    case ERROR_INVALID_CLUSTER_IPV6_ADDRESS                                       : return "The address is not valid for an IPv6 Address resource. A global IPv6 address is required, and it must match a cluster network. Compatibility addresses are not permitted";
    case ERROR_CLUSTER_INTERNAL_INVALID_FUNCTION                                  : return "An internal cluster error occurred. A call to an invalid function was attempted";
    case ERROR_CLUSTER_PARAMETER_OUT_OF_BOUNDS                                    : return "A parameter value is out of acceptable range";
    case ERROR_CLUSTER_PARTIAL_SEND                                               : return "A network error occurred while sending data to another node in the cluster. The number of bytes transmitted was less than required";
    case ERROR_CLUSTER_REGISTRY_INVALID_FUNCTION                                  : return "An invalid cluster registry operation was attempted";
    case ERROR_CLUSTER_INVALID_STRING_TERMINATION                                 : return "An input string of characters is not properly terminated";
    case ERROR_CLUSTER_INVALID_STRING_FORMAT                                      : return "An input string of characters is not in a valid format for the data it represents";
    case ERROR_CLUSTER_DATABASE_TRANSACTION_IN_PROGRESS                           : return "An internal cluster error occurred. A cluster database transaction was attempted while a transaction was already in progress";
    case ERROR_CLUSTER_DATABASE_TRANSACTION_NOT_IN_PROGRESS                       : return "An internal cluster error occurred. There was an attempt to commit a cluster database transaction while no transaction was in progress";
    case ERROR_CLUSTER_NULL_DATA                                                  : return "An internal cluster error occurred. Data was not properly initialized";
    case ERROR_CLUSTER_PARTIAL_READ                                               : return "An error occurred while reading from a stream of data. An unexpected number of bytes was returned";
    case ERROR_CLUSTER_PARTIAL_WRITE                                              : return "An error occurred while writing to a stream of data. The required number of bytes could not be written";
    case ERROR_CLUSTER_CANT_DESERIALIZE_DATA                                      : return "An error occurred while deserializing a stream of cluster data";
    case ERROR_DEPENDENT_RESOURCE_PROPERTY_CONFLICT                               : return "One or more property values for this resource are in conflict with one or more property values associated with its dependent resource(s)";
    case ERROR_CLUSTER_NO_QUORUM                                                  : return "A quorum of cluster nodes was not present to form a cluster";
    case ERROR_CLUSTER_INVALID_IPV6_NETWORK                                       : return "The cluster network is not valid for an IPv6 Address resource, or it does not match the configured address";
    case ERROR_CLUSTER_INVALID_IPV6_TUNNEL_NETWORK                                : return "The cluster network is not valid for an IPv6 Tunnel resource. Check the configuration of the IP Address resource on which the IPv6 Tunnel resource depends";
    case ERROR_QUORUM_NOT_ALLOWED_IN_THIS_GROUP                                   : return "Quorum resource cannot reside in the Available Storage group";
    case ERROR_DEPENDENCY_TREE_TOO_COMPLEX                                        : return "The dependencies for this resource are nested too deeply";
    case ERROR_EXCEPTION_IN_RESOURCE_CALL                                         : return "The call into the resource DLL raised an unhandled exception";
    case ERROR_CLUSTER_RHS_FAILED_INITIALIZATION                                  : return "The RHS process failed to initialize";
    case ERROR_CLUSTER_NOT_INSTALLED                                              : return "The Failover Clustering feature is not installed on this node";
    case ERROR_CLUSTER_RESOURCES_MUST_BE_ONLINE_ON_THE_SAME_NODE                  : return "The resources must be online on the same node for this operation";
    case ERROR_CLUSTER_MAX_NODES_IN_CLUSTER                                       : return "A new node can not be added since this cluster is already at its maximum number of nodes";
    case ERROR_CLUSTER_TOO_MANY_NODES                                             : return "This cluster can not be created since the specified number of nodes exceeds the maximum allowed limit";
    case ERROR_CLUSTER_OBJECT_ALREADY_USED                                        : return "An attempt to use the specified cluster name failed because an enabled computer object with the given name already exists in the domain";
    case ERROR_NONCORE_GROUPS_FOUND                                               : return "This cluster cannot be destroyed. It has non-core application groups which must be deleted before the cluster can be destroyed";
    case ERROR_FILE_SHARE_RESOURCE_CONFLICT                                       : return "File share associated with file share witness resource cannot be hosted by this cluster or any of its nodes";
    case ERROR_CLUSTER_EVICT_INVALID_REQUEST                                      : return "Eviction of this node is invalid at this time. Due to quorum requirements node eviction will result in cluster shutdown";
    case ERROR_CLUSTER_SINGLETON_RESOURCE                                         : return "Only one instance of this resource type is allowed in the cluster";
    case ERROR_CLUSTER_GROUP_SINGLETON_RESOURCE                                   : return "Only one instance of this resource type is allowed per resource group";
    case ERROR_CLUSTER_RESOURCE_PROVIDER_FAILED                                   : return "The resource failed to come online due to the failure of one or more provider resources";
    case ERROR_CLUSTER_RESOURCE_CONFIGURATION_ERROR                               : return "The resource has indicated that it cannot come online on any node";
    case ERROR_CLUSTER_GROUP_BUSY                                                 : return "The current operation cannot be performed on this group at this time";
    case ERROR_CLUSTER_NOT_SHARED_VOLUME                                          : return "The directory or file is not located on a cluster shared volume";
    case ERROR_CLUSTER_INVALID_SECURITY_DESCRIPTOR                                : return "The Security Descriptor does not meet the requirements for a cluster";
    case ERROR_CLUSTER_SHARED_VOLUMES_IN_USE                                      : return "There is one or more shared volumes resources configured in the cluster";
    case ERROR_CLUSTER_USE_SHARED_VOLUMES_API                                     : return "This group or resource cannot be directly manipulated";
    case ERROR_CLUSTER_BACKUP_IN_PROGRESS                                         : return "Back up is in progress. Please wait for backup completion before trying this operation again";
    case ERROR_NON_CSV_PATH                                                       : return "The path does not belong to a cluster shared volume";
    case ERROR_CSV_VOLUME_NOT_LOCAL                                               : return "The cluster shared volume is not locally mounted on this node";
    case ERROR_CLUSTER_WATCHDOG_TERMINATING                                       : return "The cluster watchdog is terminating";
    case ERROR_CLUSTER_RESOURCE_VETOED_MOVE_INCOMPATIBLE_NODES                    : return "A resource vetoed a move between two nodes because they are incompatible";
    case ERROR_CLUSTER_INVALID_NODE_WEIGHT                                        : return "The request is invalid either because node weight cannot be changed while the cluster is in disk-only quorum mode, or because changing the node weight would violate the minimum cluster quorum requirements";
    case ERROR_CLUSTER_RESOURCE_VETOED_CALL                                       : return "The resource vetoed the call";
    case ERROR_RESMON_SYSTEM_RESOURCES_LACKING                                    : return "Resource could not start or run because it could not reserve sufficient system resources";
    case ERROR_CLUSTER_RESOURCE_VETOED_MOVE_NOT_ENOUGH_RESOURCES_ON_DESTINATION   : return "A resource vetoed a move between two nodes because the destination currently does not have enough resources to complete the operation";
    case ERROR_CLUSTER_RESOURCE_VETOED_MOVE_NOT_ENOUGH_RESOURCES_ON_SOURCE        : return "A resource vetoed a move between two nodes because the source currently does not have enough resources to complete the operation";
    case ERROR_CLUSTER_GROUP_QUEUED                                               : return "The requested operation can not be completed because the group is queued for an operation";
    case ERROR_CLUSTER_RESOURCE_LOCKED_STATUS                                     : return "The requested operation can not be completed because a resource has locked status";
    case ERROR_CLUSTER_SHARED_VOLUME_FAILOVER_NOT_ALLOWED                         : return "The resource cannot move to another node because a cluster shared volume vetoed the operation";
    case ERROR_CLUSTER_NODE_DRAIN_IN_PROGRESS                                     : return "A node drain is already in progress";
    case ERROR_CLUSTER_DISK_NOT_CONNECTED                                         : return "Clustered storage is not connected to the node";
    case ERROR_DISK_NOT_CSV_CAPABLE                                               : return "The disk is not configured in a way to be used with CSV. CSV disks must have at least one partition that is formatted with NTFS or REFS";
    case ERROR_RESOURCE_NOT_IN_AVAILABLE_STORAGE                                  : return "The resource must be part of the Available Storage group to complete this action";
    case ERROR_CLUSTER_SHARED_VOLUME_REDIRECTED                                   : return "CSVFS failed operation as volume is in redirected mode";
    case ERROR_CLUSTER_SHARED_VOLUME_NOT_REDIRECTED                               : return "CSVFS failed operation as volume is not in redirected mode";
    case ERROR_CLUSTER_CANNOT_RETURN_PROPERTIES                                   : return "Cluster properties cannot be returned at this time";
    case ERROR_CLUSTER_RESOURCE_CONTAINS_UNSUPPORTED_DIFF_AREA_FOR_SHARED_VOLUMES : return "The clustered disk resource contains software snapshot diff area that are not supported for Cluster Shared Volumes";
    case ERROR_CLUSTER_RESOURCE_IS_IN_MAINTENANCE_MODE                            : return "The operation cannot be completed because the resource is in maintenance mode";
    case ERROR_CLUSTER_AFFINITY_CONFLICT                                          : return "The operation cannot be completed because of cluster affinity conflicts";
    case ERROR_CLUSTER_RESOURCE_IS_REPLICA_VIRTUAL_MACHINE                        : return "The operation cannot be completed because the resource is a replica virtual machine";
    case ERROR_CLUSTER_UPGRADE_INCOMPATIBLE_VERSIONS                              : return "The Cluster Functional Level could not be increased because not all nodes in the cluster support the updated version";
    case ERROR_CLUSTER_UPGRADE_FIX_QUORUM_NOT_SUPPORTED                           : return "Updating the cluster functional level failed because the cluster is running in fix quorum mode";
    case ERROR_CLUSTER_UPGRADE_RESTART_REQUIRED                                   : return "The cluster functional level has been successfully updated but not all features are available yet. Restart the cluster by";
    case ERROR_CLUSTER_UPGRADE_IN_PROGRESS                                        : return "The cluster is currently performing a version upgrade";
    case ERROR_CLUSTER_UPGRADE_INCOMPLETE                                         : return "The cluster did not successfully complete the version upgrade";
    case ERROR_CLUSTER_NODE_IN_GRACE_PERIOD                                       : return "The cluster node is in grace period";
    case ERROR_CLUSTER_CSV_IO_PAUSE_TIMEOUT                                       : return "The operation has failed because CSV volume was not able to recover in time specified on this file object";
    case ERROR_NODE_NOT_ACTIVE_CLUSTER_MEMBER                                     : return "The operation failed because the requested node is not currently part of active cluster membership";
    case ERROR_CLUSTER_RESOURCE_NOT_MONITORED                                     : return "The operation failed because the requested cluster resource is currently unmonitored";
    case ERROR_CLUSTER_RESOURCE_DOES_NOT_SUPPORT_UNMONITORED                      : return "The operation failed because a resource does not support running in an unmonitored state";
    case ERROR_CLUSTER_RESOURCE_IS_REPLICATED                                     : return "The operation cannot be completed because a resource participates in replication";
    case ERROR_CLUSTER_NODE_ISOLATED                                              : return "The operation failed because the requested cluster node has been isolated";
    case ERROR_CLUSTER_NODE_QUARANTINED                                           : return "The operation failed because the requested cluster node has been quarantined";
    case ERROR_CLUSTER_DATABASE_UPDATE_CONDITION_FAILED                           : return "The operation failed because the specified database update condition was not met";
    case ERROR_CLUSTER_SPACE_DEGRADED                                             : return "A clustered space is in a degraded condition and the requested action cannot be completed at this time";
    case ERROR_CLUSTER_TOKEN_DELEGATION_NOT_SUPPORTED                             : return "The operation failed because token delegation for this control is not supported";
    case ERROR_CLUSTER_CSV_INVALID_HANDLE                                         : return "The operation has failed because CSV has invalidated this file object";
    case ERROR_CLUSTER_CSV_SUPPORTED_ONLY_ON_COORDINATOR                          : return "This operation is supported only on the CSV coordinator node";
    case ERROR_GROUPSET_NOT_AVAILABLE                                             : return "The cluster group set is not available for any further requests";
    case ERROR_GROUPSET_NOT_FOUND                                                 : return "The cluster group set could not be found";
    case ERROR_GROUPSET_CANT_PROVIDE                                              : return "The action cannot be completed at this time because the cluster group set would fall below quorum and not be able to act as a provider";
    case ERROR_CLUSTER_FAULT_DOMAIN_PARENT_NOT_FOUND                              : return "The specified parent fault domain is not found";
    case ERROR_CLUSTER_FAULT_DOMAIN_INVALID_HIERARCHY                             : return "The fault domain cannot be a child of the parent specified";
    case ERROR_CLUSTER_FAULT_DOMAIN_FAILED_S2D_VALIDATION                         : return "Storage Spaces Direct has rejected the proposed fault domain changes because it impacts the fault tolerance of the storage";
    case ERROR_CLUSTER_FAULT_DOMAIN_S2D_CONNECTIVITY_LOSS                         : return "Storage Spaces Direct has rejected the proposed fault domain changes because it reduces the storage connected to the system";
    case ERROR_CLUSTER_INVALID_INFRASTRUCTURE_FILESERVER_NAME                     : return "Cluster infrastructure file server creation failed because a valid non-empty file server name was not provided";
    case ERROR_CLUSTERSET_MANAGEMENT_CLUSTER_UNREACHABLE                          : return "The action cannot be completed because the cluster set managenement cluster is unreachable";
    case ERROR_ENCRYPTION_FAILED                                                  : return "The specified file could not be encrypted";
    case ERROR_DECRYPTION_FAILED                                                  : return "The specified file could not be decrypted";
    case ERROR_FILE_ENCRYPTED                                                     : return "The specified file is encrypted and the user does not have the ability to decrypt it";
    case ERROR_NO_RECOVERY_POLICY                                                 : return "There is no valid encryption recovery policy configured for this system";
    case ERROR_NO_EFS                                                             : return "The required encryption driver is not loaded for this system";
    case ERROR_WRONG_EFS                                                          : return "The file was encrypted with a different encryption driver than is currently loaded";
    case ERROR_NO_USER_KEYS                                                       : return "There are no EFS keys defined for the user";
    case ERROR_FILE_NOT_ENCRYPTED                                                 : return "The specified file is not encrypted";
    case ERROR_NOT_EXPORT_FORMAT                                                  : return "The specified file is not in the defined EFS export format";
    case ERROR_FILE_READ_ONLY                                                     : return "The specified file is read only";
    case ERROR_DIR_EFS_DISALLOWED                                                 : return "The directory has been disabled for encryption";
    case ERROR_EFS_SERVER_NOT_TRUSTED                                             : return "The server is not trusted for remote encryption operation";
    case ERROR_BAD_RECOVERY_POLICY                                                : return "Recovery policy configured for this system contains invalid recovery certificate";
    case ERROR_EFS_ALG_BLOB_TOO_BIG                                               : return "The encryption algorithm used on the source file needs a bigger key buffer than the one on the destination file";
    case ERROR_VOLUME_NOT_SUPPORT_EFS                                             : return "The disk partition does not support file encryption";
    case ERROR_EFS_DISABLED                                                       : return "This machine is disabled for file encryption";
    case ERROR_EFS_VERSION_NOT_SUPPORT                                            : return "A newer system is required to decrypt this encrypted file";
    case ERROR_CS_ENCRYPTION_INVALID_SERVER_RESPONSE                              : return "The remote server sent an invalid response for a file being opened with Client Side Encryption";
    case ERROR_CS_ENCRYPTION_UNSUPPORTED_SERVER                                   : return "Client Side Encryption is not supported by the remote server even though it claims to support it";
    case ERROR_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE                              : return "File is encrypted and should be opened in Client Side Encryption mode";
    case ERROR_CS_ENCRYPTION_NEW_ENCRYPTED_FILE                                   : return "A new encrypted file is being created and a $EFS needs to be provided";
    case ERROR_CS_ENCRYPTION_FILE_NOT_CSE                                         : return "The SMB client requested a CSE FSCTL on a non-CSE file";
    case ERROR_ENCRYPTION_POLICY_DENIES_OPERATION                                 : return "The requested operation was blocked by policy. For more information, contact your system administrator";
    case ERROR_NO_BROWSER_SERVERS_FOUND                                           : return "The list of servers for this workgroup is not currently available";
    case SCHED_E_SERVICE_NOT_LOCALSYSTEM                                          : return "The Task Scheduler service must be configured to run in the System account to function properly. Individual tasks may be configured to run in other accounts";
    case ERROR_LOG_SECTOR_INVALID                                                 : return "Log service encountered an invalid log sector";
    case ERROR_LOG_SECTOR_PARITY_INVALID                                          : return "Log service encountered a log sector with invalid block parity";
    case ERROR_LOG_SECTOR_REMAPPED                                                : return "Log service encountered a remapped log sector";
    case ERROR_LOG_BLOCK_INCOMPLETE                                               : return "Log service encountered a partial or incomplete log block";
    case ERROR_LOG_INVALID_RANGE                                                  : return "Log service encountered an attempt access data outside the active log range";
    case ERROR_LOG_BLOCKS_EXHAUSTED                                               : return "Log service user marshalling buffers are exhausted";
    case ERROR_LOG_READ_CONTEXT_INVALID                                           : return "Log service encountered an attempt read from a marshalling area with an invalid read context";
    case ERROR_LOG_RESTART_INVALID                                                : return "Log service encountered an invalid log restart area";
    case ERROR_LOG_BLOCK_VERSION                                                  : return "Log service encountered an invalid log block version";
    case ERROR_LOG_BLOCK_INVALID                                                  : return "Log service encountered an invalid log block";
    case ERROR_LOG_READ_MODE_INVALID                                              : return "Log service encountered an attempt to read the log with an invalid read mode";
    case ERROR_LOG_NO_RESTART                                                     : return "Log service encountered a log stream with no restart area";
    case ERROR_LOG_METADATA_CORRUPT                                               : return "Log service encountered a corrupted metadata file";
    case ERROR_LOG_METADATA_INVALID                                               : return "Log service encountered a metadata file that could not be created by the log file system";
    case ERROR_LOG_METADATA_INCONSISTENT                                          : return "Log service encountered a metadata file with inconsistent data";
    case ERROR_LOG_RESERVATION_INVALID                                            : return "Log service encountered an attempt to erroneous allocate or dispose reservation space";
    case ERROR_LOG_CANT_DELETE                                                    : return "Log service cannot delete log file or file system container";
    case ERROR_LOG_CONTAINER_LIMIT_EXCEEDED                                       : return "Log service has reached the maximum allowable containers allocated to a log file";
    case ERROR_LOG_START_OF_LOG                                                   : return "Log service has attempted to read or write backward past the start of the log";
    case ERROR_LOG_POLICY_ALREADY_INSTALLED                                       : return "Log policy could not be installed because a policy of the same type is already present";
    case ERROR_LOG_POLICY_NOT_INSTALLED                                           : return "Log policy in question was not installed at the time of the request";
    case ERROR_LOG_POLICY_INVALID                                                 : return "The installed set of policies on the log is invalid";
    case ERROR_LOG_POLICY_CONFLICT                                                : return "A policy on the log in question prevented the operation from completing";
    case ERROR_LOG_PINNED_ARCHIVE_TAIL                                            : return "Log space cannot be reclaimed because the log is pinned by the archive tail";
    case ERROR_LOG_RECORD_NONEXISTENT                                             : return "Log record is not a record in the log file";
    case ERROR_LOG_RECORDS_RESERVED_INVALID                                       : return "Number of reserved log records or the adjustment of the number of reserved log records is invalid";
    case ERROR_LOG_SPACE_RESERVED_INVALID                                         : return "Reserved log space or the adjustment of the log space is invalid";
    case ERROR_LOG_TAIL_INVALID                                                   : return "An new or existing archive tail or base of the active log is invalid";
    case ERROR_LOG_FULL                                                           : return "Log space is exhausted";
    case ERROR_COULD_NOT_RESIZE_LOG                                               : return "The log could not be set to the requested size";
    case ERROR_LOG_MULTIPLEXED                                                    : return "Log is multiplexed, no direct writes to the physical log is allowed";
    case ERROR_LOG_DEDICATED                                                      : return "The operation failed because the log is a dedicated log";
    case ERROR_LOG_ARCHIVE_NOT_IN_PROGRESS                                        : return "The operation requires an archive context";
    case ERROR_LOG_ARCHIVE_IN_PROGRESS                                            : return "Log archival is in progress";
    case ERROR_LOG_EPHEMERAL                                                      : return "The operation requires a non-ephemeral log, but the log is ephemeral";
    case ERROR_LOG_NOT_ENOUGH_CONTAINERS                                          : return "The log must have at least two containers before it can be read from or written to";
    case ERROR_LOG_CLIENT_ALREADY_REGISTERED                                      : return "A log client has already registered on the stream";
    case ERROR_LOG_CLIENT_NOT_REGISTERED                                          : return "A log client has not been registered on the stream";
    case ERROR_LOG_FULL_HANDLER_IN_PROGRESS                                       : return "A request has already been made to handle the log full condition";
    case ERROR_LOG_CONTAINER_READ_FAILED                                          : return "Log service encountered an error when attempting to read from a log container";
    case ERROR_LOG_CONTAINER_WRITE_FAILED                                         : return "Log service encountered an error when attempting to write to a log container";
    case ERROR_LOG_CONTAINER_OPEN_FAILED                                          : return "Log service encountered an error when attempting open a log container";
    case ERROR_LOG_CONTAINER_STATE_INVALID                                        : return "Log service encountered an invalid container state when attempting a requested action";
    case ERROR_LOG_STATE_INVALID                                                  : return "Log service is not in the correct state to perform a requested action";
    case ERROR_LOG_PINNED                                                         : return "Log space cannot be reclaimed because the log is pinned";
    case ERROR_LOG_METADATA_FLUSH_FAILED                                          : return "Log metadata flush failed";
    case ERROR_LOG_INCONSISTENT_SECURITY                                          : return "Security on the log and its containers is inconsistent";
    case ERROR_LOG_APPENDED_FLUSH_FAILED                                          : return "Records were appended to the log or reservation changes were made, but the log could not be flushed";
    case ERROR_LOG_PINNED_RESERVATION                                             : return "The log is pinned due to reservation consuming most of the log space. Free some reserved records to make space available";
    case ERROR_INVALID_TRANSACTION                                                : return "The transaction handle associated with this operation is not valid";
    case ERROR_TRANSACTION_NOT_ACTIVE                                             : return "The requested operation was made in the context of a transaction that is no longer active";
    case ERROR_TRANSACTION_REQUEST_NOT_VALID                                      : return "The requested operation is not valid on the Transaction object in its current state";
    case ERROR_TRANSACTION_NOT_REQUESTED                                          : return "The caller has called a response API, but the response is not expected because the TM did not issue the corresponding request to the caller";
    case ERROR_TRANSACTION_ALREADY_ABORTED                                        : return "It is too late to perform the requested operation, since the Transaction has already been aborted";
    case ERROR_TRANSACTION_ALREADY_COMMITTED                                      : return "It is too late to perform the requested operation, since the Transaction has already been committed";
    case ERROR_TM_INITIALIZATION_FAILED                                           : return "The Transaction Manager was unable to be successfully initialized. Transacted operations are not supported";
    case ERROR_RESOURCEMANAGER_READ_ONLY                                          : return "The specified ResourceManager made no changes or updates to the resource under this transaction";
    case ERROR_TRANSACTION_NOT_JOINED                                             : return "The resource manager has attempted to prepare a transaction that it has not successfully joined";
    case ERROR_TRANSACTION_SUPERIOR_EXISTS                                        : return "The Transaction object already has a superior enlistment, and the caller attempted an operation that would have created a new superior. Only a single superior enlistment is allow";
    case ERROR_CRM_PROTOCOL_ALREADY_EXISTS                                        : return "The RM tried to register a protocol that already exists";
    case ERROR_TRANSACTION_PROPAGATION_FAILED                                     : return "The attempt to propagate the Transaction failed";
    case ERROR_CRM_PROTOCOL_NOT_FOUND                                             : return "The requested propagation protocol was not registered as a CRM";
    case ERROR_TRANSACTION_INVALID_MARSHALL_BUFFER                                : return "The buffer passed in to PushTransaction or PullTransaction is not in a valid format";
    case ERROR_CURRENT_TRANSACTION_NOT_VALID                                      : return "The current transaction context associated with the thread is not a valid handle to a transaction object";
    case ERROR_TRANSACTION_NOT_FOUND                                              : return "The specified Transaction object could not be opened, because it was not found";
    case ERROR_RESOURCEMANAGER_NOT_FOUND                                          : return "The specified ResourceManager object could not be opened, because it was not found";
    case ERROR_ENLISTMENT_NOT_FOUND                                               : return "The specified Enlistment object could not be opened, because it was not found";
    case ERROR_TRANSACTIONMANAGER_NOT_FOUND                                       : return "The specified TransactionManager object could not be opened, because it was not found";
    case ERROR_TRANSACTIONMANAGER_NOT_ONLINE                                      : return "The object specified could not be created or opened, because its associated TransactionManager is not online.  The TransactionManager must be brought fully Online by calling RecoverTransactionManager to recover to the end of its LogFile before objects in its Transaction or ResourceManager namespaces can be opened.  In addition, errors in writing records to its LogFile can cause a TransactionManager to go offline";
    case ERROR_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION                         : return "The specified TransactionManager was unable to create the objects contained in its logfile in the Ob namespace. Therefore, the TransactionManager was unable to recover";
    case ERROR_TRANSACTION_NOT_ROOT                                               : return "The call to create a superior Enlistment on this Transaction object could not be completed, because the Transaction object specified for the enlistment is a subordinate branch of the Transaction. Only the root of the Transaction can be enlisted on as a superior";
    case ERROR_TRANSACTION_OBJECT_EXPIRED                                         : return "Because the associated transaction manager or resource manager has been closed, the handle is no longer valid";
    case ERROR_TRANSACTION_RESPONSE_NOT_ENLISTED                                  : return "The specified operation could not be performed on this Superior enlistment, because the enlistment was not created with the corresponding completion response in the NotificationMask";
    case ERROR_TRANSACTION_RECORD_TOO_LONG                                        : return "The specified operation could not be performed, because the record that would be logged was too long. This can occur because of two conditions: either there are too many Enlistments on this Transaction, or the combined RecoveryInformation being logged on behalf of those Enlistments is too long";
    case ERROR_IMPLICIT_TRANSACTION_NOT_SUPPORTED                                 : return "Implicit transaction are not supported";
    case ERROR_TRANSACTION_INTEGRITY_VIOLATED                                     : return "The kernel transaction manager had to abort or forget the transaction because it blocked forward progress";
    case ERROR_TRANSACTIONMANAGER_IDENTITY_MISMATCH                               : return "The TransactionManager identity that was supplied did not match the one recorded in the TransactionManager's log file";
    case ERROR_RM_CANNOT_BE_FROZEN_FOR_SNAPSHOT                                   : return "This snapshot operation cannot continue because a transactional resource manager cannot be frozen in its current state.  Please try again";
    case ERROR_TRANSACTION_MUST_WRITETHROUGH                                      : return "The transaction cannot be enlisted on with the specified EnlistmentMask, because the transaction has already completed the PrePrepare phase.  In order to ensure correctness, the ResourceManager must switch to a write-through mode and cease caching data within this transaction.  Enlisting for only subsequent transaction phases may still succeed";
    case ERROR_TRANSACTION_NO_SUPERIOR                                            : return "The transaction does not have a superior enlistment";
    case ERROR_HEURISTIC_DAMAGE_POSSIBLE                                          : return "The attempt to commit the Transaction completed, but it is possible that some portion of the transaction tree did not commit successfully due to heuristics.  Therefore it is possible that some data modified in the transaction may not have committed, resulting in transactional inconsistency.  If possible, check the consistency of the associated data";
    case ERROR_TRANSACTIONAL_CONFLICT                                             : return "The function attempted to use a name that is reserved for use by another transaction";
    case ERROR_RM_NOT_ACTIVE                                                      : return "Transaction support within the specified resource manager is not started or was shut down due to an error";
    case ERROR_RM_METADATA_CORRUPT                                                : return "The metadata of the RM has been corrupted. The RM will not function";
    case ERROR_DIRECTORY_NOT_RM                                                   : return "The specified directory does not contain a resource manager";
    case ERROR_TRANSACTIONS_UNSUPPORTED_REMOTE                                    : return "The remote server or share does not support transacted file operations";
    case ERROR_LOG_RESIZE_INVALID_SIZE                                            : return "The requested log size is invalid";
    case ERROR_OBJECT_NO_LONGER_EXISTS                                            : return "The object (file, stream, link) corresponding to the handle has been deleted by a Transaction Savepoint Rollback";
    case ERROR_STREAM_MINIVERSION_NOT_FOUND                                       : return "The specified file miniversion was not found for this transacted file open";
    case ERROR_STREAM_MINIVERSION_NOT_VALID                                       : return "The specified file miniversion was found but has been invalidated. Most likely cause is a transaction savepoint rollback";
    case ERROR_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION                : return "A miniversion may only be opened in the context of the transaction that created it";
    case ERROR_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT                           : return "It is not possible to open a miniversion with modify access";
    case ERROR_CANT_CREATE_MORE_STREAM_MINIVERSIONS                               : return "It is not possible to create any more miniversions for this stream";
    case ERROR_REMOTE_FILE_VERSION_MISMATCH                                       : return "The remote server sent mismatching version number or Fid for a file opened with transactions";
    case ERROR_HANDLE_NO_LONGER_VALID                                             : return "The handle has been invalidated by a transaction. The most likely cause is the presence of memory mapping on a file or an open handle when the transaction ended or rolled back to savepoint";
    case ERROR_NO_TXF_METADATA                                                    : return "There is no transaction metadata on the file";
    case ERROR_LOG_CORRUPTION_DETECTED                                            : return "The log data is corrupt";
    case ERROR_CANT_RECOVER_WITH_HANDLE_OPEN                                      : return "The file can't be recovered because there is a handle still open on it";
    case ERROR_RM_DISCONNECTED                                                    : return "The transaction outcome is unavailable because the resource manager responsible for it has disconnected";
    case ERROR_ENLISTMENT_NOT_SUPERIOR                                            : return "The request was rejected because the enlistment in question is not a superior enlistment";
    case ERROR_RECOVERY_NOT_NEEDED                                                : return "The transactional resource manager is already consistent. Recovery is not needed";
    case ERROR_RM_ALREADY_STARTED                                                 : return "The transactional resource manager has already been started";
    case ERROR_FILE_IDENTITY_NOT_PERSISTENT                                       : return "The file cannot be opened transactionally, because its identity depends on the outcome of an unresolved transaction";
    case ERROR_CANT_BREAK_TRANSACTIONAL_DEPENDENCY                                : return "The operation cannot be performed because another transaction is depending on the fact that this property will not change";
    case ERROR_CANT_CROSS_RM_BOUNDARY                                             : return "The operation would involve a single file with two transactional resource managers and is therefore not allowed";
    case ERROR_TXF_DIR_NOT_EMPTY                                                  : return "The $Txf directory must be empty for this operation to succeed";
    case ERROR_INDOUBT_TRANSACTIONS_EXIST                                         : return "The operation would leave a transactional resource manager in an inconsistent state and is therefore not allowed";
    case ERROR_TM_VOLATILE                                                        : return "The operation could not be completed because the transaction manager does not have a log";
    case ERROR_ROLLBACK_TIMER_EXPIRED                                             : return "A rollback could not be scheduled because a previously scheduled rollback has already executed or been queued for execution";
    case ERROR_TXF_ATTRIBUTE_CORRUPT                                              : return "The transactional metadata attribute on the file or directory is corrupt and unreadable";
    case ERROR_EFS_NOT_ALLOWED_IN_TRANSACTION                                     : return "The encryption operation could not be completed because a transaction is active";
    case ERROR_TRANSACTIONAL_OPEN_NOT_ALLOWED                                     : return "This object is not allowed to be opened in a transaction";
    case ERROR_LOG_GROWTH_FAILED                                                  : return "An attempt to create space in the transactional resource manager's log failed. The failure status has been recorded in the event log";
    case ERROR_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE                              : return "Memory mapping (creating a mapped section) a remote file under a transaction is not supported";
    case ERROR_TXF_METADATA_ALREADY_PRESENT                                       : return "Transaction metadata is already present on this file and cannot be superseded";
    case ERROR_TRANSACTION_SCOPE_CALLBACKS_NOT_SET                                : return "A transaction scope could not be entered because the scope handler has not been initialized";
    case ERROR_TRANSACTION_REQUIRED_PROMOTION                                     : return "Promotion was required in order to allow the resource manager to enlist, but the transaction was set to disallow it";
    case ERROR_CANNOT_EXECUTE_FILE_IN_TRANSACTION                                 : return "This file is open for modification in an unresolved transaction and may be opened for execute only by a transacted reader";
    case ERROR_TRANSACTIONS_NOT_FROZEN                                            : return "The request to thaw frozen transactions was ignored because transactions had not previously been frozen";
    case ERROR_TRANSACTION_FREEZE_IN_PROGRESS                                     : return "Transactions cannot be frozen because a freeze is already in progress";
    case ERROR_NOT_SNAPSHOT_VOLUME                                                : return "The target volume is not a snapshot volume. This operation is only valid on a volume mounted as a snapshot";
    case ERROR_NO_SAVEPOINT_WITH_OPEN_FILES                                       : return "The savepoint operation failed because files are open on the transaction. This is not permitted";
    case ERROR_DATA_LOST_REPAIR                                                   : return "Windows has discovered corruption in a file, and that file has since been repaired. Data loss may have occurred";
    case ERROR_SPARSE_NOT_ALLOWED_IN_TRANSACTION                                  : return "The sparse operation could not be completed because a transaction is active on the file";
    case ERROR_TM_IDENTITY_MISMATCH                                               : return "The call to create a TransactionManager object failed because the Tm Identity stored in the logfile does not match the Tm Identity that was passed in as an argument";
    case ERROR_FLOATED_SECTION                                                    : return "I/O was attempted on a section object that has been floated as a result of a transaction ending. There is no valid data";
    case ERROR_CANNOT_ACCEPT_TRANSACTED_WORK                                      : return "The transactional resource manager cannot currently accept transacted work due to a transient condition such as low resources";
    case ERROR_CANNOT_ABORT_TRANSACTIONS                                          : return "The transactional resource manager had too many tranactions outstanding that could not be aborted. The transactional resource manger has been shut down";
    case ERROR_BAD_CLUSTERS                                                       : return "The operation could not be completed due to bad clusters on disk";
    case ERROR_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION                             : return "The compression operation could not be completed because a transaction is active on the file";
    case ERROR_VOLUME_DIRTY                                                       : return "The operation could not be completed because the volume is dirty. Please run chkdsk and try again";
    case ERROR_NO_LINK_TRACKING_IN_TRANSACTION                                    : return "The link tracking operation could not be completed because a transaction is active";
    case ERROR_OPERATION_NOT_SUPPORTED_IN_TRANSACTION                             : return "This operation cannot be performed in a transaction";
    case ERROR_EXPIRED_HANDLE                                                     : return "The handle is no longer properly associated with its transaction.  It may have been opened in a transactional resource manager that was subsequently forced to restart.  Please close the handle and open a new one";
    case ERROR_TRANSACTION_NOT_ENLISTED                                           : return "The specified operation could not be performed because the resource manager is not enlisted in the transaction";
    case ERROR_CTX_WINSTATION_NAME_INVALID                                        : return "The specified session name is invalid";
    case ERROR_CTX_INVALID_PD                                                     : return "The specified protocol driver is invalid";
    case ERROR_CTX_PD_NOT_FOUND                                                   : return "The specified protocol driver was not found in the system path";
    case ERROR_CTX_WD_NOT_FOUND                                                   : return "The specified terminal connection driver was not found in the system path";
    case ERROR_CTX_CANNOT_MAKE_EVENTLOG_ENTRY                                     : return "A registry key for event logging could not be created for this session";
    case ERROR_CTX_SERVICE_NAME_COLLISION                                         : return "A service with the same name already exists on the system";
    case ERROR_CTX_CLOSE_PENDING                                                  : return "A close operation is pending on the session";
    case ERROR_CTX_NO_OUTBUF                                                      : return "There are no free output buffers available";
    case ERROR_CTX_MODEM_INF_NOT_FOUND                                            : return "The MODEM.INF file was not found";
    case ERROR_CTX_INVALID_MODEMNAME                                              : return "The modem name was not found in MODEM.INF";
    case ERROR_CTX_MODEM_RESPONSE_ERROR                                           : return "The modem did not accept the command sent to it. Verify that the configured modem name matches the attached modem";
    case ERROR_CTX_MODEM_RESPONSE_TIMEOUT                                         : return "The modem did not respond to the command sent to it. Verify that the modem is properly cabled and powered on";
    case ERROR_CTX_MODEM_RESPONSE_NO_CARRIER                                      : return "Carrier detect has failed or carrier has been dropped due to disconnect";
    case ERROR_CTX_MODEM_RESPONSE_NO_DIALTONE                                     : return "Dial tone not detected within the required time. Verify that the phone cable is properly attached and functional";
    case ERROR_CTX_MODEM_RESPONSE_BUSY                                            : return "Busy signal detected at remote site on callback";
    case ERROR_CTX_MODEM_RESPONSE_VOICE                                           : return "Voice detected at remote site on callback";
    case ERROR_CTX_TD_ERROR                                                       : return "Transport driver error";
    case ERROR_CTX_WINSTATION_NOT_FOUND                                           : return "The specified session cannot be found";
    case ERROR_CTX_WINSTATION_ALREADY_EXISTS                                      : return "The specified session name is already in use";
    case ERROR_CTX_WINSTATION_BUSY                                                : return "The task you are trying to do can't be completed because Remote Desktop Services is currently busy. Please try again in a few minutes. Other users should still be able to log on";
    case ERROR_CTX_BAD_VIDEO_MODE                                                 : return "An attempt has been made to connect to a session whose video mode is not supported by the current client";
    case ERROR_CTX_GRAPHICS_INVALID                                               : return "The application attempted to enable DOS graphics mode. DOS graphics mode is not supported";
    case ERROR_CTX_LOGON_DISABLED                                                 : return "Your interactive logon privilege has been disabled. Please contact your administrator";
    case ERROR_CTX_NOT_CONSOLE                                                    : return "The requested operation can be performed only on the system console. This is most often the result of a driver or system DLL requiring direct console access";
    case ERROR_CTX_CLIENT_QUERY_TIMEOUT                                           : return "The client failed to respond to the server connect message";
    case ERROR_CTX_CONSOLE_DISCONNECT                                             : return "Disconnecting the console session is not supported";
    case ERROR_CTX_CONSOLE_CONNECT                                                : return "Reconnecting a disconnected session to the console is not supported";
    case ERROR_CTX_SHADOW_DENIED                                                  : return "The request to control another session remotely was denied";
    case ERROR_CTX_WINSTATION_ACCESS_DENIED                                       : return "The requested session access is denied";
    case ERROR_CTX_INVALID_WD                                                     : return "The specified terminal connection driver is invalid";
    case ERROR_CTX_SHADOW_INVALID                                                 : return "The requested session cannot be controlled remotely";
    case ERROR_CTX_SHADOW_DISABLED                                                : return "The requested session is not configured to allow remote control";
    case ERROR_CTX_CLIENT_LICENSE_IN_USE                                          : return "Your request to connect to this Terminal Server has been rejected. Your Terminal Server client license number is currently being used by another user. Please call your system administrator to obtain a unique license number";
    case ERROR_CTX_CLIENT_LICENSE_NOT_SET                                         : return "Your request to connect to this Terminal Server has been rejected. Your Terminal Server client license number has not been entered for this copy of the Terminal Server client. Please contact your system administrator";
    case ERROR_CTX_LICENSE_NOT_AVAILABLE                                          : return "The number of connections to this computer is limited and all connections are in use right now. Try connecting later or contact your system administrator";
    case ERROR_CTX_LICENSE_CLIENT_INVALID                                         : return "The client you are using is not licensed to use this system. Your logon request is denied";
    case ERROR_CTX_LICENSE_EXPIRED                                                : return "The system license has expired. Your logon request is denied";
    case ERROR_CTX_SHADOW_NOT_RUNNING                                             : return "Remote control could not be terminated because the specified session is not currently being remotely controlled";
    case ERROR_CTX_SHADOW_ENDED_BY_MODE_CHANGE                                    : return "The remote control of the console was terminated because the display mode was changed. Changing the display mode in a remote control session is not supported";
    case ERROR_ACTIVATION_COUNT_EXCEEDED                                          : return "Activation has already been reset the maximum number of times for this installation. Your activation timer will not be cleared";
    case ERROR_CTX_WINSTATIONS_DISABLED                                           : return "Remote logins are currently disabled";
    case ERROR_CTX_ENCRYPTION_LEVEL_REQUIRED                                      : return "You do not have the proper encryption level to access this Session";
    case ERROR_CTX_SESSION_IN_USE                                                 : return "The user %%s\\\\%%s is currently logged on to this computer. Only the current user or an administrator can log on to this computer";
    case ERROR_CTX_NO_FORCE_LOGOFF                                                : return "The user %%s\\\\%%s is already logged on to the console of this computer. You do not have permission to log in at this time. To resolve this issue, contact %%s\\\\%%s and have them log off";
    case ERROR_CTX_ACCOUNT_RESTRICTION                                            : return "Unable to log you on because of an account restriction";
    case ERROR_RDP_PROTOCOL_ERROR                                                 : return "The RDP protocol component %%2 detected an error in the protocol stream and has disconnected the client";
    case ERROR_CTX_CDM_CONNECT                                                    : return "The Client Drive Mapping Service Has Connected on Terminal Connection";
    case ERROR_CTX_CDM_DISCONNECT                                                 : return "The Client Drive Mapping Service Has Disconnected on Terminal Connection";
    case ERROR_CTX_SECURITY_LAYER_ERROR                                           : return "The Terminal Server security layer detected an error in the protocol stream and has disconnected the client";
    case ERROR_TS_INCOMPATIBLE_SESSIONS                                           : return "The target session is incompatible with the current session";
    case ERROR_TS_VIDEO_SUBSYSTEM_ERROR                                           : return "Windows can't connect to your session because a problem occurred in the Windows video subsystem. Try connecting again later, or contact the server administrator for assistance";
    case FRS_ERR_INVALID_API_SEQUENCE                                             : return "The file replication service API was called incorrectly";
    case FRS_ERR_STARTING_SERVICE                                                 : return "The file replication service cannot be started";
    case FRS_ERR_STOPPING_SERVICE                                                 : return "The file replication service cannot be stopped";
    case FRS_ERR_INTERNAL_API                                                     : return "The file replication service API terminated the request. The event log may have more information";
    case FRS_ERR_INTERNAL                                                         : return "The file replication service terminated the request. The event log may have more information";
    case FRS_ERR_SERVICE_COMM                                                     : return "The file replication service cannot be contacted. The event log may have more information";
    case FRS_ERR_INSUFFICIENT_PRIV                                                : return "The file replication service cannot satisfy the request because the user has insufficient privileges. The event log may have more information";
    case FRS_ERR_AUTHENTICATION                                                   : return "The file replication service cannot satisfy the request because authenticated RPC is not available. The event log may have more information";
    case FRS_ERR_PARENT_INSUFFICIENT_PRIV                                         : return "The file replication service cannot satisfy the request because the user has insufficient privileges on the domain controller. The event log may have more information";
    case FRS_ERR_PARENT_AUTHENTICATION                                            : return "The file replication service cannot satisfy the request because authenticated RPC is not available on the domain controller. The event log may have more information";
    case FRS_ERR_CHILD_TO_PARENT_COMM                                             : return "The file replication service cannot communicate with the file replication service on the domain controller. The event log may have more information";
    case FRS_ERR_PARENT_TO_CHILD_COMM                                             : return "The file replication service on the domain controller cannot communicate with the file replication service on this computer. The event log may have more information";
    case FRS_ERR_SYSVOL_POPULATE                                                  : return "The file replication service cannot populate the system volume because of an internal error. The event log may have more information";
    case FRS_ERR_SYSVOL_POPULATE_TIMEOUT                                          : return "The file replication service cannot populate the system volume because of an internal timeout. The event log may have more information";
    case FRS_ERR_SYSVOL_IS_BUSY                                                   : return "The file replication service cannot process the request. The system volume is busy with a previous request";
    case FRS_ERR_SYSVOL_DEMOTE                                                    : return "The file replication service cannot stop replicating the system volume because of an internal error. The event log may have more information";
    case FRS_ERR_INVALID_SERVICE_PARAMETER                                        : return "The file replication service detected an invalid parameter";
    case ERROR_DS_NOT_INSTALLED                                                   : return "An error occurred while installing the directory service. For more information, see the event log";
    case ERROR_DS_MEMBERSHIP_EVALUATED_LOCALLY                                    : return "The directory service evaluated group memberships locally";
    case ERROR_DS_NO_ATTRIBUTE_OR_VALUE                                           : return "The specified directory service attribute or value does not exist";
    case ERROR_DS_INVALID_ATTRIBUTE_SYNTAX                                        : return "The attribute syntax specified to the directory service is invalid";
    case ERROR_DS_ATTRIBUTE_TYPE_UNDEFINED                                        : return "The attribute type specified to the directory service is not defined";
    case ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS                                       : return "The specified directory service attribute or value already exists";
    case ERROR_DS_BUSY                                                            : return "The directory service is busy";
    case ERROR_DS_UNAVAILABLE                                                     : return "The directory service is unavailable";
    case ERROR_DS_NO_RIDS_ALLOCATED                                               : return "The directory service was unable to allocate a relative identifier";
    case ERROR_DS_NO_MORE_RIDS                                                    : return "The directory service has exhausted the pool of relative identifiers";
    case ERROR_DS_INCORRECT_ROLE_OWNER                                            : return "The requested operation could not be performed because the directory service is not the master for that type of operation";
    case ERROR_DS_RIDMGR_INIT_ERROR                                               : return "The directory service was unable to initialize the subsystem that allocates relative identifiers";
    case ERROR_DS_OBJ_CLASS_VIOLATION                                             : return "The requested operation did not satisfy one or more constraints associated with the class of the object";
    case ERROR_DS_CANT_ON_NON_LEAF                                                : return "The directory service can perform the requested operation only on a leaf object";
    case ERROR_DS_CANT_ON_RDN                                                     : return "The directory service cannot perform the requested operation on the RDN attribute of an object";
    case ERROR_DS_CANT_MOD_OBJ_CLASS                                              : return "The directory service detected an attempt to modify the object class of an object";
    case ERROR_DS_CROSS_DOM_MOVE_ERROR                                            : return "The requested cross-domain move operation could not be performed";
    case ERROR_DS_GC_NOT_AVAILABLE                                                : return "Unable to contact the global catalog server";
    case ERROR_SHARED_POLICY                                                      : return "The policy object is shared and can only be modified at the root";
    case ERROR_POLICY_OBJECT_NOT_FOUND                                            : return "The policy object does not exist";
    case ERROR_POLICY_ONLY_IN_DS                                                  : return "The requested policy information is only in the directory service";
    case ERROR_PROMOTION_ACTIVE                                                   : return "A domain controller promotion is currently active";
    case ERROR_NO_PROMOTION_ACTIVE                                                : return "A domain controller promotion is not currently active";
    case ERROR_DS_OPERATIONS_ERROR                                                : return "An operations error occurred";
    case ERROR_DS_PROTOCOL_ERROR                                                  : return "A protocol error occurred";
    case ERROR_DS_TIMELIMIT_EXCEEDED                                              : return "The time limit for this request was exceeded";
    case ERROR_DS_SIZELIMIT_EXCEEDED                                              : return "The size limit for this request was exceeded";
    case ERROR_DS_ADMIN_LIMIT_EXCEEDED                                            : return "The administrative limit for this request was exceeded";
    case ERROR_DS_COMPARE_FALSE                                                   : return "The compare response was false";
    case ERROR_DS_COMPARE_TRUE                                                    : return "The compare response was true";
    case ERROR_DS_AUTH_METHOD_NOT_SUPPORTED                                       : return "The requested authentication method is not supported by the server";
    case ERROR_DS_STRONG_AUTH_REQUIRED                                            : return "A more secure authentication method is required for this server";
    case ERROR_DS_INAPPROPRIATE_AUTH                                              : return "Inappropriate authentication";
    case ERROR_DS_AUTH_UNKNOWN                                                    : return "The authentication mechanism is unknown";
    case ERROR_DS_REFERRAL                                                        : return "A referral was returned from the server";
    case ERROR_DS_UNAVAILABLE_CRIT_EXTENSION                                      : return "The server does not support the requested critical extension";
    case ERROR_DS_CONFIDENTIALITY_REQUIRED                                        : return "This request requires a secure connection";
    case ERROR_DS_INAPPROPRIATE_MATCHING                                          : return "Inappropriate matching";
    case ERROR_DS_CONSTRAINT_VIOLATION                                            : return "A constraint violation occurred";
    case ERROR_DS_NO_SUCH_OBJECT                                                  : return "There is no such object on the server";
    case ERROR_DS_ALIAS_PROBLEM                                                   : return "There is an alias problem";
    case ERROR_DS_INVALID_DN_SYNTAX                                               : return "An invalid dn syntax has been specified";
    case ERROR_DS_IS_LEAF                                                         : return "The object is a leaf object";
    case ERROR_DS_ALIAS_DEREF_PROBLEM                                             : return "There is an alias dereferencing problem";
    case ERROR_DS_UNWILLING_TO_PERFORM                                            : return "The server is unwilling to process the request";
    case ERROR_DS_LOOP_DETECT                                                     : return "A loop has been detected";
    case ERROR_DS_NAMING_VIOLATION                                                : return "There is a naming violation";
    case ERROR_DS_OBJECT_RESULTS_TOO_LARGE                                        : return "The result set is too large";
    case ERROR_DS_AFFECTS_MULTIPLE_DSAS                                           : return "The operation affects multiple DSAs";
    case ERROR_DS_SERVER_DOWN                                                     : return "The server is not operational";
    case ERROR_DS_LOCAL_ERROR                                                     : return "A local error has occurred";
    case ERROR_DS_ENCODING_ERROR                                                  : return "An encoding error has occurred";
    case ERROR_DS_DECODING_ERROR                                                  : return "A decoding error has occurred";
    case ERROR_DS_FILTER_UNKNOWN                                                  : return "The search filter cannot be recognized";
    case ERROR_DS_PARAM_ERROR                                                     : return "One or more parameters are illegal";
    case ERROR_DS_NOT_SUPPORTED                                                   : return "The specified method is not supported";
    case ERROR_DS_NO_RESULTS_RETURNED                                             : return "No results were returned";
    case ERROR_DS_CONTROL_NOT_FOUND                                               : return "The specified control is not supported by the server";
    case ERROR_DS_CLIENT_LOOP                                                     : return "A referral loop was detected by the client";
    case ERROR_DS_REFERRAL_LIMIT_EXCEEDED                                         : return "The preset referral limit was exceeded";
    case ERROR_DS_SORT_CONTROL_MISSING                                            : return "The search requires a SORT control";
    case ERROR_DS_OFFSET_RANGE_ERROR                                              : return "The search results exceed the offset range specified";
    case ERROR_DS_RIDMGR_DISABLED                                                 : return "The directory service detected the subsystem that allocates relative identifiers is disabled. This can occur as a protective mechanism when the system determines a significant portion of relative identifiers (RIDs) have been exhausted. Please see http://go.microsoft.com/fwlink/?LinkId=228610 for recommended diagnostic steps and the procedure to re-enable account creation";
    case ERROR_DS_ROOT_MUST_BE_NC                                                 : return "The root object must be the head of a naming context. The root object cannot have an instantiated parent";
    case ERROR_DS_ADD_REPLICA_INHIBITED                                           : return "The add replica operation cannot be performed. The naming context must be writeable in order to create the replica";
    case ERROR_DS_ATT_NOT_DEF_IN_SCHEMA                                           : return "A reference to an attribute that is not defined in the schema occurred";
    case ERROR_DS_MAX_OBJ_SIZE_EXCEEDED                                           : return "The maximum size of an object has been exceeded";
    case ERROR_DS_OBJ_STRING_NAME_EXISTS                                          : return "An attempt was made to add an object to the directory with a name that is already in use";
    case ERROR_DS_NO_RDN_DEFINED_IN_SCHEMA                                        : return "An attempt was made to add an object of a class that does not have an RDN defined in the schema";
    case ERROR_DS_RDN_DOESNT_MATCH_SCHEMA                                         : return "An attempt was made to add an object using an RDN that is not the RDN defined in the schema";
    case ERROR_DS_NO_REQUESTED_ATTS_FOUND                                         : return "None of the requested attributes were found on the objects";
    case ERROR_DS_USER_BUFFER_TO_SMALL                                            : return "The user buffer is too small";
    case ERROR_DS_ATT_IS_NOT_ON_OBJ                                               : return "The attribute specified in the operation is not present on the object";
    case ERROR_DS_ILLEGAL_MOD_OPERATION                                           : return "Illegal modify operation. Some aspect of the modification is not permitted";
    case ERROR_DS_OBJ_TOO_LARGE                                                   : return "The specified object is too large";
    case ERROR_DS_BAD_INSTANCE_TYPE                                               : return "The specified instance type is not valid";
    case ERROR_DS_MASTERDSA_REQUIRED                                              : return "The operation must be performed at a master DSA";
    case ERROR_DS_OBJECT_CLASS_REQUIRED                                           : return "The object class attribute must be specified";
    case ERROR_DS_MISSING_REQUIRED_ATT                                            : return "A required attribute is missing";
    case ERROR_DS_ATT_NOT_DEF_FOR_CLASS                                           : return "An attempt was made to modify an object to include an attribute that is not legal for its class";
    case ERROR_DS_ATT_ALREADY_EXISTS                                              : return "The specified attribute is already present on the object";
    case ERROR_DS_CANT_ADD_ATT_VALUES                                             : return "The specified attribute is not present, or has no values";
    case ERROR_DS_SINGLE_VALUE_CONSTRAINT                                         : return "Multiple values were specified for an attribute that can have only one value";
    case ERROR_DS_RANGE_CONSTRAINT                                                : return "A value for the attribute was not in the acceptable range of values";
    case ERROR_DS_ATT_VAL_ALREADY_EXISTS                                          : return "The specified value already exists";
    case ERROR_DS_CANT_REM_MISSING_ATT                                            : return "The attribute cannot be removed because it is not present on the object";
    case ERROR_DS_CANT_REM_MISSING_ATT_VAL                                        : return "The attribute value cannot be removed because it is not present on the object";
    case ERROR_DS_ROOT_CANT_BE_SUBREF                                             : return "The specified root object cannot be a subref";
    case ERROR_DS_NO_CHAINING                                                     : return "Chaining is not permitted";
    case ERROR_DS_NO_CHAINED_EVAL                                                 : return "Chained evaluation is not permitted";
    case ERROR_DS_NO_PARENT_OBJECT                                                : return "The operation could not be performed because the object's parent is either uninstantiated or deleted";
    case ERROR_DS_PARENT_IS_AN_ALIAS                                              : return "Having a parent that is an alias is not permitted. Aliases are leaf objects";
    case ERROR_DS_CANT_MIX_MASTER_AND_REPS                                        : return "The object and parent must be of the same type, either both masters or both replicas";
    case ERROR_DS_CHILDREN_EXIST                                                  : return "The operation cannot be performed because child objects exist. This operation can only be performed on a leaf object";
    case ERROR_DS_OBJ_NOT_FOUND                                                   : return "Directory object not found";
    case ERROR_DS_ALIASED_OBJ_MISSING                                             : return "The aliased object is missing";
    case ERROR_DS_BAD_NAME_SYNTAX                                                 : return "The object name has bad syntax";
    case ERROR_DS_ALIAS_POINTS_TO_ALIAS                                           : return "It is not permitted for an alias to refer to another alias";
    case ERROR_DS_CANT_DEREF_ALIAS                                                : return "The alias cannot be dereferenced";
    case ERROR_DS_OUT_OF_SCOPE                                                    : return "The operation is out of scope";
    case ERROR_DS_OBJECT_BEING_REMOVED                                            : return "The operation cannot continue because the object is in the process of being removed";
    case ERROR_DS_CANT_DELETE_DSA_OBJ                                             : return "The DSA object cannot be deleted";
    case ERROR_DS_GENERIC_ERROR                                                   : return "A directory service error has occurred";
    case ERROR_DS_DSA_MUST_BE_INT_MASTER                                          : return "The operation can only be performed on an internal master DSA object";
    case ERROR_DS_CLASS_NOT_DSA                                                   : return "The object must be of class DSA";
    case ERROR_DS_INSUFF_ACCESS_RIGHTS                                            : return "Insufficient access rights to perform the operation";
    case ERROR_DS_ILLEGAL_SUPERIOR                                                : return "The object cannot be added because the parent is not on the list of possible superiors";
    case ERROR_DS_ATTRIBUTE_OWNED_BY_SAM                                          : return "Access to the attribute is not permitted because the attribute is owned by the Security Accounts Manager (SAM)";
    case ERROR_DS_NAME_TOO_MANY_PARTS                                             : return "The name has too many parts";
    case ERROR_DS_NAME_TOO_LONG                                                   : return "The name is too long";
    case ERROR_DS_NAME_VALUE_TOO_LONG                                             : return "The name value is too long";
    case ERROR_DS_NAME_UNPARSEABLE                                                : return "The directory service encountered an error parsing a name";
    case ERROR_DS_NAME_TYPE_UNKNOWN                                               : return "The directory service cannot get the attribute type for a name";
    case ERROR_DS_NOT_AN_OBJECT                                                   : return "The name does not identify an object; the name identifies a phantom";
    case ERROR_DS_SEC_DESC_TOO_SHORT                                              : return "The security descriptor is too short";
    case ERROR_DS_SEC_DESC_INVALID                                                : return "The security descriptor is invalid";
    case ERROR_DS_NO_DELETED_NAME                                                 : return "Failed to create name for deleted object";
    case ERROR_DS_SUBREF_MUST_HAVE_PARENT                                         : return "The parent of a new subref must exist";
    case ERROR_DS_NCNAME_MUST_BE_NC                                               : return "The object must be a naming context";
    case ERROR_DS_CANT_ADD_SYSTEM_ONLY                                            : return "It is not permitted to add an attribute which is owned by the system";
    case ERROR_DS_CLASS_MUST_BE_CONCRETE                                          : return "The class of the object must be structural; you cannot instantiate an abstract class";
    case ERROR_DS_INVALID_DMD                                                     : return "The schema object could not be found";
    case ERROR_DS_OBJ_GUID_EXISTS                                                 : return "A local object with this GUID (dead or alive) already exists";
    case ERROR_DS_NOT_ON_BACKLINK                                                 : return "The operation cannot be performed on a back link";
    case ERROR_DS_NO_CROSSREF_FOR_NC                                              : return "The cross reference for the specified naming context could not be found";
    case ERROR_DS_SHUTTING_DOWN                                                   : return "The operation could not be performed because the directory service is shutting down";
    case ERROR_DS_UNKNOWN_OPERATION                                               : return "The directory service request is invalid";
    case ERROR_DS_INVALID_ROLE_OWNER                                              : return "The role owner attribute could not be read";
    case ERROR_DS_COULDNT_CONTACT_FSMO                                            : return "The requested FSMO operation failed. The current FSMO holder could not be contacted";
    case ERROR_DS_CROSS_NC_DN_RENAME                                              : return "Modification of a DN across a naming context is not permitted";
    case ERROR_DS_CANT_MOD_SYSTEM_ONLY                                            : return "The attribute cannot be modified because it is owned by the system";
    case ERROR_DS_REPLICATOR_ONLY                                                 : return "Only the replicator can perform this function";
    case ERROR_DS_OBJ_CLASS_NOT_DEFINED                                           : return "The specified class is not defined";
    case ERROR_DS_OBJ_CLASS_NOT_SUBCLASS                                          : return "The specified class is not a subclass";
    case ERROR_DS_NAME_REFERENCE_INVALID                                          : return "The name reference is invalid";
    case ERROR_DS_CROSS_REF_EXISTS                                                : return "A cross reference already exists";
    case ERROR_DS_CANT_DEL_MASTER_CROSSREF                                        : return "It is not permitted to delete a master cross reference";
    case ERROR_DS_SUBTREE_NOTIFY_NOT_NC_HEAD                                      : return "Subtree notifications are only supported on NC heads";
    case ERROR_DS_NOTIFY_FILTER_TOO_COMPLEX                                       : return "Notification filter is too complex";
    case ERROR_DS_DUP_RDN                                                         : return "Schema update failed: duplicate RDN";
    case ERROR_DS_DUP_OID                                                         : return "Schema update failed: duplicate OID";
    case ERROR_DS_DUP_MAPI_ID                                                     : return "Schema update failed: duplicate MAPI identifier";
    case ERROR_DS_DUP_SCHEMA_ID_GUID                                              : return "Schema update failed: duplicate schema-id GUID";
    case ERROR_DS_DUP_LDAP_DISPLAY_NAME                                           : return "Schema update failed: duplicate LDAP display name";
    case ERROR_DS_SEMANTIC_ATT_TEST                                               : return "Schema update failed: range-lower less than range upper";
    case ERROR_DS_SYNTAX_MISMATCH                                                 : return "Schema update failed: syntax mismatch";
    case ERROR_DS_EXISTS_IN_MUST_HAVE                                             : return "Schema deletion failed: attribute is used in must-contain";
    case ERROR_DS_EXISTS_IN_MAY_HAVE                                              : return "Schema deletion failed: attribute is used in may-contain";
    case ERROR_DS_NONEXISTENT_MAY_HAVE                                            : return "Schema update failed: attribute in may-contain does not exist";
    case ERROR_DS_NONEXISTENT_MUST_HAVE                                           : return "Schema update failed: attribute in must-contain does not exist";
    case ERROR_DS_AUX_CLS_TEST_FAIL                                               : return "Schema update failed: class in aux-class list does not exist or is not an auxiliary class";
    case ERROR_DS_NONEXISTENT_POSS_SUP                                            : return "Schema update failed: class in poss-superiors does not exist";
    case ERROR_DS_SUB_CLS_TEST_FAIL                                               : return "Schema update failed: class in subclassof list does not exist or does not satisfy hierarchy rules";
    case ERROR_DS_BAD_RDN_ATT_ID_SYNTAX                                           : return "Schema update failed: Rdn-Att-Id has wrong syntax";
    case ERROR_DS_EXISTS_IN_AUX_CLS                                               : return "Schema deletion failed: class is used as auxiliary class";
    case ERROR_DS_EXISTS_IN_SUB_CLS                                               : return "Schema deletion failed: class is used as sub class";
    case ERROR_DS_EXISTS_IN_POSS_SUP                                              : return "Schema deletion failed: class is used as poss superior";
    case ERROR_DS_RECALCSCHEMA_FAILED                                             : return "Schema update failed in recalculating validation cache";
    case ERROR_DS_TREE_DELETE_NOT_FINISHED                                        : return "The tree deletion is not finished. The request must be made again to continue deleting the tree";
    case ERROR_DS_CANT_DELETE                                                     : return "The requested delete operation could not be performed";
    case ERROR_DS_ATT_SCHEMA_REQ_ID                                               : return "Cannot read the governs class identifier for the schema record";
    case ERROR_DS_BAD_ATT_SCHEMA_SYNTAX                                           : return "The attribute schema has bad syntax";
    case ERROR_DS_CANT_CACHE_ATT                                                  : return "The attribute could not be cached";
    case ERROR_DS_CANT_CACHE_CLASS                                                : return "The class could not be cached";
    case ERROR_DS_CANT_REMOVE_ATT_CACHE                                           : return "The attribute could not be removed from the cache";
    case ERROR_DS_CANT_REMOVE_CLASS_CACHE                                         : return "The class could not be removed from the cache";
    case ERROR_DS_CANT_RETRIEVE_DN                                                : return "The distinguished name attribute could not be read";
    case ERROR_DS_MISSING_SUPREF                                                  : return "No superior reference has been configured for the directory service. The directory service is therefore unable to issue referrals to objects outside this forest";
    case ERROR_DS_CANT_RETRIEVE_INSTANCE                                          : return "The instance type attribute could not be retrieved";
    case ERROR_DS_CODE_INCONSISTENCY                                              : return "An internal error has occurred";
    case ERROR_DS_DATABASE_ERROR                                                  : return "A database error has occurred";
    case ERROR_DS_GOVERNSID_MISSING                                               : return "The attribute GOVERNSID is missing";
    case ERROR_DS_MISSING_EXPECTED_ATT                                            : return "An expected attribute is missing";
    case ERROR_DS_NCNAME_MISSING_CR_REF                                           : return "The specified naming context is missing a cross reference";
    case ERROR_DS_SECURITY_CHECKING_ERROR                                         : return "A security checking error has occurred";
    case ERROR_DS_SCHEMA_NOT_LOADED                                               : return "The schema is not loaded";
    case ERROR_DS_SCHEMA_ALLOC_FAILED                                             : return "Schema allocation failed. Please check if the machine is running low on memory";
    case ERROR_DS_ATT_SCHEMA_REQ_SYNTAX                                           : return "Failed to obtain the required syntax for the attribute schema";
    case ERROR_DS_GCVERIFY_ERROR                                                  : return "The global catalog verification failed. The global catalog is not available or does not support the operation. Some part of the directory is currently not available";
    case ERROR_DS_DRA_SCHEMA_MISMATCH                                             : return "The replication operation failed because of a schema mismatch between the servers involved";
    case ERROR_DS_CANT_FIND_DSA_OBJ                                               : return "The DSA object could not be found";
    case ERROR_DS_CANT_FIND_EXPECTED_NC                                           : return "The naming context could not be found";
    case ERROR_DS_CANT_FIND_NC_IN_CACHE                                           : return "The naming context could not be found in the cache";
    case ERROR_DS_CANT_RETRIEVE_CHILD                                             : return "The child object could not be retrieved";
    case ERROR_DS_SECURITY_ILLEGAL_MODIFY                                         : return "The modification was not permitted for security reasons";
    case ERROR_DS_CANT_REPLACE_HIDDEN_REC                                         : return "The operation cannot replace the hidden record";
    case ERROR_DS_BAD_HIERARCHY_FILE                                              : return "The hierarchy file is invalid";
    case ERROR_DS_BUILD_HIERARCHY_TABLE_FAILED                                    : return "The attempt to build the hierarchy table failed";
    case ERROR_DS_CONFIG_PARAM_MISSING                                            : return "The directory configuration parameter is missing from the registry";
    case ERROR_DS_COUNTING_AB_INDICES_FAILED                                      : return "The attempt to count the address book indices failed";
    case ERROR_DS_HIERARCHY_TABLE_MALLOC_FAILED                                   : return "The allocation of the hierarchy table failed";
    case ERROR_DS_INTERNAL_FAILURE                                                : return "The directory service encountered an internal failure";
    case ERROR_DS_UNKNOWN_ERROR                                                   : return "The directory service encountered an unknown failure";
    case ERROR_DS_ROOT_REQUIRES_CLASS_TOP                                         : return "A root object requires a class of 'top'";
    case ERROR_DS_REFUSING_FSMO_ROLES                                             : return "This directory server is shutting down, and cannot take ownership of new floating single-master operation roles";
    case ERROR_DS_MISSING_FSMO_SETTINGS                                           : return "The directory service is missing mandatory configuration information, and is unable to determine the ownership of floating single-master operation roles";
    case ERROR_DS_UNABLE_TO_SURRENDER_ROLES                                       : return "The directory service was unable to transfer ownership of one or more floating single-master operation roles to other servers";
    case ERROR_DS_DRA_GENERIC                                                     : return "The replication operation failed";
    case ERROR_DS_DRA_INVALID_PARAMETER                                           : return "An invalid parameter was specified for this replication operation";
    case ERROR_DS_DRA_BUSY                                                        : return "The directory service is too busy to complete the replication operation at this time";
    case ERROR_DS_DRA_BAD_DN                                                      : return "The distinguished name specified for this replication operation is invalid";
    case ERROR_DS_DRA_BAD_NC                                                      : return "The naming context specified for this replication operation is invalid";
    case ERROR_DS_DRA_DN_EXISTS                                                   : return "The distinguished name specified for this replication operation already exists";
    case ERROR_DS_DRA_INTERNAL_ERROR                                              : return "The replication system encountered an internal error";
    case ERROR_DS_DRA_INCONSISTENT_DIT                                            : return "The replication operation encountered a database inconsistency";
    case ERROR_DS_DRA_CONNECTION_FAILED                                           : return "The server specified for this replication operation could not be contacted";
    case ERROR_DS_DRA_BAD_INSTANCE_TYPE                                           : return "The replication operation encountered an object with an invalid instance type";
    case ERROR_DS_DRA_OUT_OF_MEM                                                  : return "The replication operation failed to allocate memory";
    case ERROR_DS_DRA_MAIL_PROBLEM                                                : return "The replication operation encountered an error with the mail system";
    case ERROR_DS_DRA_REF_ALREADY_EXISTS                                          : return "The replication reference information for the target server already exists";
    case ERROR_DS_DRA_REF_NOT_FOUND                                               : return "The replication reference information for the target server does not exist";
    case ERROR_DS_DRA_OBJ_IS_REP_SOURCE                                           : return "The naming context cannot be removed because it is replicated to another server";
    case ERROR_DS_DRA_DB_ERROR                                                    : return "The replication operation encountered a database error";
    case ERROR_DS_DRA_NO_REPLICA                                                  : return "The naming context is in the process of being removed or is not replicated from the specified server";
    case ERROR_DS_DRA_ACCESS_DENIED                                               : return "Replication access was denied";
    case ERROR_DS_DRA_NOT_SUPPORTED                                               : return "The requested operation is not supported by this version of the directory service";
    case ERROR_DS_DRA_RPC_CANCELLED                                               : return "The replication remote procedure call was cancelled";
    case ERROR_DS_DRA_SOURCE_DISABLED                                             : return "The source server is currently rejecting replication requests";
    case ERROR_DS_DRA_SINK_DISABLED                                               : return "The destination server is currently rejecting replication requests";
    case ERROR_DS_DRA_NAME_COLLISION                                              : return "The replication operation failed due to a collision of object names";
    case ERROR_DS_DRA_SOURCE_REINSTALLED                                          : return "The replication source has been reinstalled";
    case ERROR_DS_DRA_MISSING_PARENT                                              : return "The replication operation failed because a required parent object is missing";
    case ERROR_DS_DRA_PREEMPTED                                                   : return "The replication operation was preempted";
    case ERROR_DS_DRA_ABANDON_SYNC                                                : return "The replication synchronization attempt was abandoned because of a lack of updates";
    case ERROR_DS_DRA_SHUTDOWN                                                    : return "The replication operation was terminated because the system is shutting down";
    case ERROR_DS_DRA_INCOMPATIBLE_PARTIAL_SET                                    : return "Synchronization attempt failed because the destination DC is currently waiting to synchronize new partial attributes from source. This condition is normal if a recent schema change modified the partial attribute set. The destination partial attribute set is not a subset of source partial attribute set";
    case ERROR_DS_DRA_SOURCE_IS_PARTIAL_REPLICA                                   : return "The replication synchronization attempt failed because a master replica attempted to sync from a partial replica";
    case ERROR_DS_DRA_EXTN_CONNECTION_FAILED                                      : return "The server specified for this replication operation was contacted, but that server was unable to contact an additional server needed to complete the operation";
    case ERROR_DS_INSTALL_SCHEMA_MISMATCH                                         : return "The version of the directory service schema of the source forest is not compatible with the version of directory service on this computer";
    case ERROR_DS_DUP_LINK_ID                                                     : return "Schema update failed: An attribute with the same link identifier already exists";
    case ERROR_DS_NAME_ERROR_RESOLVING                                            : return "Name translation: Generic processing error";
    case ERROR_DS_NAME_ERROR_NOT_FOUND                                            : return "Name translation: Could not find the name or insufficient right to see name";
    case ERROR_DS_NAME_ERROR_NOT_UNIQUE                                           : return "Name translation: Input name mapped to more than one output name";
    case ERROR_DS_NAME_ERROR_NO_MAPPING                                           : return "Name translation: Input name found, but not the associated output format";
    case ERROR_DS_NAME_ERROR_DOMAIN_ONLY                                          : return "Name translation: Unable to resolve completely, only the domain was found";
    case ERROR_DS_NAME_ERROR_NO_SYNTACTICAL_MAPPING                               : return "Name translation: Unable to perform purely syntactical mapping at the client without going out to the wire";
    case ERROR_DS_CONSTRUCTED_ATT_MOD                                             : return "Modification of a constructed attribute is not allowed";
    case ERROR_DS_WRONG_OM_OBJ_CLASS                                              : return "The OM-Object-Class specified is incorrect for an attribute with the specified syntax";
    case ERROR_DS_DRA_REPL_PENDING                                                : return "The replication request has been posted; waiting for reply";
    case ERROR_DS_DS_REQUIRED                                                     : return "The requested operation requires a directory service, and none was available";
    case ERROR_DS_INVALID_LDAP_DISPLAY_NAME                                       : return "The LDAP display name of the class or attribute contains non-ASCII characters";
    case ERROR_DS_NON_BASE_SEARCH                                                 : return "The requested search operation is only supported for base searches";
    case ERROR_DS_CANT_RETRIEVE_ATTS                                              : return "The search failed to retrieve attributes from the database";
    case ERROR_DS_BACKLINK_WITHOUT_LINK                                           : return "The schema update operation tried to add a backward link attribute that has no corresponding forward link";
    case ERROR_DS_EPOCH_MISMATCH                                                  : return "Source and destination of a cross-domain move do not agree on the object's epoch number. Either source or destination does not have the latest version of the object";
    case ERROR_DS_SRC_NAME_MISMATCH                                               : return "Source and destination of a cross-domain move do not agree on the object's current name. Either source or destination does not have the latest version of the object";
    case ERROR_DS_SRC_AND_DST_NC_IDENTICAL                                        : return "Source and destination for the cross-domain move operation are identical. Caller should use local move operation instead of cross-domain move operation";
    case ERROR_DS_DST_NC_MISMATCH                                                 : return "Source and destination for a cross-domain move are not in agreement on the naming contexts in the forest. Either source or destination does not have the latest version of the Partitions container";
    case ERROR_DS_NOT_AUTHORITIVE_FOR_DST_NC                                      : return "Destination of a cross-domain move is not authoritative for the destination naming context";
    case ERROR_DS_SRC_GUID_MISMATCH                                               : return "Source and destination of a cross-domain move do not agree on the identity of the source object. Either source or destination does not have the latest version of the source object";
    case ERROR_DS_CANT_MOVE_DELETED_OBJECT                                        : return "Object being moved across-domains is already known to be deleted by the destination server. The source server does not have the latest version of the source object";
    case ERROR_DS_PDC_OPERATION_IN_PROGRESS                                       : return "Another operation which requires exclusive access to the PDC FSMO is already in progress";
    case ERROR_DS_CROSS_DOMAIN_CLEANUP_REQD                                       : return "A cross-domain move operation failed such that two versions of the moved object exist - one each in the source and destination domains. The destination object needs to be removed to restore the system to a consistent state";
    case ERROR_DS_ILLEGAL_XDOM_MOVE_OPERATION                                     : return "This object may not be moved across domain boundaries either because cross-domain moves for this class are disallowed, or the object has some special characteristics, e.g.: trust account or restricted RID, which prevent its move";
    case ERROR_DS_CANT_WITH_ACCT_GROUP_MEMBERSHPS                                 : return "Can't move objects with memberships across domain boundaries as once moved, this would violate the membership conditions of the account group. Remove the object from any account group memberships and retry";
    case ERROR_DS_NC_MUST_HAVE_NC_PARENT                                          : return "A naming context head must be the immediate child of another naming context head, not of an interior node";
    case ERROR_DS_CR_IMPOSSIBLE_TO_VALIDATE                                       : return "The directory cannot validate the proposed naming context name because it does not hold a replica of the naming context above the proposed naming context. Please ensure that the domain naming master role is held by a server that is configured as a global catalog server, and that the server is up to date with its replication partners. (Applies only to Windows 2000 Domain Naming masters)";
    case ERROR_DS_DST_DOMAIN_NOT_NATIVE                                           : return "Destination domain must be in native mode";
    case ERROR_DS_MISSING_INFRASTRUCTURE_CONTAINER                                : return "The operation cannot be performed because the server does not have an infrastructure container in the domain of interest";
    case ERROR_DS_CANT_MOVE_ACCOUNT_GROUP                                         : return "Cross-domain move of non-empty account groups is not allowed";
    case ERROR_DS_CANT_MOVE_RESOURCE_GROUP                                        : return "Cross-domain move of non-empty resource groups is not allowed";
    case ERROR_DS_INVALID_SEARCH_FLAG                                             : return "The search flags for the attribute are invalid. The ANR bit is valid only on attributes of Unicode or Teletex strings";
    case ERROR_DS_NO_TREE_DELETE_ABOVE_NC                                         : return "Tree deletions starting at an object which has an NC head as a descendant are not allowed";
    case ERROR_DS_COULDNT_LOCK_TREE_FOR_DELETE                                    : return "The directory service failed to lock a tree in preparation for a tree deletion because the tree was in use";
    case ERROR_DS_COULDNT_IDENTIFY_OBJECTS_FOR_TREE_DELETE                        : return "The directory service failed to identify the list of objects to delete while attempting a tree deletion";
    case ERROR_DS_SAM_INIT_FAILURE                                                : return "Security Accounts Manager initialization failed because of the following error: %%1";
    case ERROR_DS_SENSITIVE_GROUP_VIOLATION                                       : return "Only an administrator can modify the membership list of an administrative group";
    case ERROR_DS_CANT_MOD_PRIMARYGROUPID                                         : return "Cannot change the primary group ID of a domain controller account";
    case ERROR_DS_ILLEGAL_BASE_SCHEMA_MOD                                         : return "An attempt is made to modify the base schema";
    case ERROR_DS_NONSAFE_SCHEMA_CHANGE                                           : return "Adding a new mandatory attribute to an existing class, deleting a mandatory attribute from an existing class, or adding an optional attribute to the special class Top that is not a backlink attribute (directly or through inheritance, for example, by adding or deleting an auxiliary class) is not allowed";
    case ERROR_DS_SCHEMA_UPDATE_DISALLOWED                                        : return "Schema update is not allowed on this DC because the DC is not the schema FSMO Role Owner";
    case ERROR_DS_CANT_CREATE_UNDER_SCHEMA                                        : return "An object of this class cannot be created under the schema container. You can only create attribute-schema and class-schema objects under the schema container";
    case ERROR_DS_INSTALL_NO_SRC_SCH_VERSION                                      : return "The replica/child install failed to get the objectVersion attribute on the schema container on the source DC. Either the attribute is missing on the schema container or the credentials supplied do not have permission to read it";
    case ERROR_DS_INSTALL_NO_SCH_VERSION_IN_INIFILE                               : return "The replica/child install failed to read the objectVersion attribute in the SCHEMA section of the file schema.ini in the system32 directory";
    case ERROR_DS_INVALID_GROUP_TYPE                                              : return "The specified group type is invalid";
    case ERROR_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN                              : return "You cannot nest global groups in a mixed domain if the group is security-enabled";
    case ERROR_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN                               : return "You cannot nest local groups in a mixed domain if the group is security-enabled";
    case ERROR_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER                                   : return "A global group cannot have a local group as a member";
    case ERROR_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER                               : return "A global group cannot have a universal group as a member";
    case ERROR_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER                                : return "A universal group cannot have a local group as a member";
    case ERROR_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER                             : return "A global group cannot have a cross-domain member";
    case ERROR_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER                        : return "A local group cannot have another cross domain local group as a member";
    case ERROR_DS_HAVE_PRIMARY_MEMBERS                                            : return "A group with primary members cannot change to a security-disabled group";
    case ERROR_DS_STRING_SD_CONVERSION_FAILED                                     : return "The schema cache load failed to convert the string default SD on a class-schema object";
    case ERROR_DS_NAMING_MASTER_GC                                                : return "Only DSAs configured to be Global Catalog servers should be allowed to hold the Domain Naming Master FSMO role. (Applies only to Windows 2000 servers)";
    case ERROR_DS_DNS_LOOKUP_FAILURE                                              : return "The DSA operation is unable to proceed because of a DNS lookup failure";
    case ERROR_DS_COULDNT_UPDATE_SPNS                                             : return "While processing a change to the DNS Host Name for an object, the Service Principal Name values could not be kept in sync";
    case ERROR_DS_CANT_RETRIEVE_SD                                                : return "The Security Descriptor attribute could not be read";
    case ERROR_DS_KEY_NOT_UNIQUE                                                  : return "The object requested was not found, but an object with that key was found";
    case ERROR_DS_WRONG_LINKED_ATT_SYNTAX                                         : return "The syntax of the linked attribute being added is incorrect. Forward links can only have syntax 2.5.5.1, 2.5.5.7, and 2.5.5.14, and backlinks can only have syntax 2.5.5.1";
    case ERROR_DS_SAM_NEED_BOOTKEY_PASSWORD                                       : return "Security Account Manager needs to get the boot password";
    case ERROR_DS_SAM_NEED_BOOTKEY_FLOPPY                                         : return "Security Account Manager needs to get the boot key from floppy disk";
    case ERROR_DS_CANT_START                                                      : return "Directory Service cannot start";
    case ERROR_DS_INIT_FAILURE                                                    : return "Directory Services could not start";
    case ERROR_DS_NO_PKT_PRIVACY_ON_CONNECTION                                    : return "The connection between client and server requires packet privacy or better";
    case ERROR_DS_SOURCE_DOMAIN_IN_FOREST                                         : return "The source domain may not be in the same forest as destination";
    case ERROR_DS_DESTINATION_DOMAIN_NOT_IN_FOREST                                : return "The destination domain must be in the forest";
    case ERROR_DS_DESTINATION_AUDITING_NOT_ENABLED                                : return "The operation requires that destination domain auditing be enabled";
    case ERROR_DS_CANT_FIND_DC_FOR_SRC_DOMAIN                                     : return "The operation couldn't locate a DC for the source domain";
    case ERROR_DS_SRC_OBJ_NOT_GROUP_OR_USER                                       : return "The source object must be a group or user";
    case ERROR_DS_SRC_SID_EXISTS_IN_FOREST                                        : return "The source object's SID already exists in destination forest";
    case ERROR_DS_SRC_AND_DST_OBJECT_CLASS_MISMATCH                               : return "The source and destination object must be of the same type";
    case ERROR_SAM_INIT_FAILURE                                                   : return "Security Accounts Manager initialization failed because of the following error: %%1";
    case ERROR_DS_DRA_SCHEMA_INFO_SHIP                                            : return "Schema information could not be included in the replication request";
    case ERROR_DS_DRA_SCHEMA_CONFLICT                                             : return "The replication operation could not be completed due to a schema incompatibility";
    case ERROR_DS_DRA_EARLIER_SCHEMA_CONFLICT                                     : return "The replication operation could not be completed due to a previous schema incompatibility";
    case ERROR_DS_DRA_OBJ_NC_MISMATCH                                             : return "The replication update could not be applied because either the source or the destination has not yet received information regarding a recent cross-domain move operation";
    case ERROR_DS_NC_STILL_HAS_DSAS                                               : return "The requested domain could not be deleted because there exist domain controllers that still host this domain";
    case ERROR_DS_GC_REQUIRED                                                     : return "The requested operation can be performed only on a global catalog server";
    case ERROR_DS_LOCAL_MEMBER_OF_LOCAL_ONLY                                      : return "A local group can only be a member of other local groups in the same domain";
    case ERROR_DS_NO_FPO_IN_UNIVERSAL_GROUPS                                      : return "Foreign security principals cannot be members of universal groups";
    case ERROR_DS_CANT_ADD_TO_GC                                                  : return "The attribute is not allowed to be replicated to the GC because of security reasons";
    case ERROR_DS_NO_CHECKPOINT_WITH_PDC                                          : return "The checkpoint with the PDC could not be taken because there too many modifications being processed currently";
    case ERROR_DS_SOURCE_AUDITING_NOT_ENABLED                                     : return "The operation requires that source domain auditing be enabled";
    case ERROR_DS_CANT_CREATE_IN_NONDOMAIN_NC                                     : return "Security principal objects can only be created inside domain naming contexts";
    case ERROR_DS_INVALID_NAME_FOR_SPN                                            : return "A Service Principal Name (SPN) could not be constructed because the provided hostname is not in the necessary format";
    case ERROR_DS_FILTER_USES_CONTRUCTED_ATTRS                                    : return "A Filter was passed that uses constructed attributes";
    case ERROR_DS_UNICODEPWD_NOT_IN_QUOTES                                        : return "The unicodePwd attribute value must be enclosed in double quotes";
    case ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED                                  : return "Your computer could not be joined to the domain. You have exceeded the maximum number of computer accounts you are allowed to create in this domain. Contact your system administrator to have this limit reset or increased";
    case ERROR_DS_MUST_BE_RUN_ON_DST_DC                                           : return "For security reasons, the operation must be run on the destination DC";
    case ERROR_DS_SRC_DC_MUST_BE_SP4_OR_GREATER                                   : return "For security reasons, the source DC must be NT4SP4 or greater";
    case ERROR_DS_CANT_TREE_DELETE_CRITICAL_OBJ                                   : return "Critical Directory Service System objects cannot be deleted during tree delete operations. The tree delete may have been partially performed";
    case ERROR_DS_INIT_FAILURE_CONSOLE                                            : return "Directory Services could not start because of the following error: %%1";
    case ERROR_DS_SAM_INIT_FAILURE_CONSOLE                                        : return "Security Accounts Manager initialization failed because of the following error: %%1";
    case ERROR_DS_FOREST_VERSION_TOO_HIGH                                         : return "The version of the operating system is incompatible with the current AD DS forest functional level or AD LDS Configuration Set functional level. You must upgrade to a new version of the operating system before this server can become an AD DS Domain Controller or add an AD LDS Instance in this AD DS Forest or AD LDS Configuration Set";
    case ERROR_DS_DOMAIN_VERSION_TOO_HIGH                                         : return "The version of the operating system installed is incompatible with the current domain functional level. You must upgrade to a new version of the operating system before this server can become a domain controller in this domain";
    case ERROR_DS_FOREST_VERSION_TOO_LOW                                          : return "The version of the operating system installed on this server no longer supports the current AD DS Forest functional level or AD LDS Configuration Set functional level. You must raise the AD DS Forest functional level or AD LDS Configuration Set functional level before this server can become an AD DS Domain Controller or an AD LDS Instance in this Forest or Configuration Set";
    case ERROR_DS_DOMAIN_VERSION_TOO_LOW                                          : return "The version of the operating system installed on this server no longer supports the current domain functional level. You must raise the domain functional level before this server can become a domain controller in this domain";
    case ERROR_DS_INCOMPATIBLE_VERSION                                            : return "The version of the operating system installed on this server is incompatible with the functional level of the domain or forest";
    case ERROR_DS_LOW_DSA_VERSION                                                 : return "The functional level of the domain (or forest) cannot be raised to the requested value, because there exist one or more domain controllers in the domain (or forest) that are at a lower incompatible functional level";
    case ERROR_DS_NO_BEHAVIOR_VERSION_IN_MIXEDDOMAIN                              : return "The forest functional level cannot be raised to the requested value since one or more domains are still in mixed domain mode. All domains in the forest must be in native mode, for you to raise the forest functional level";
    case ERROR_DS_NOT_SUPPORTED_SORT_ORDER                                        : return "The sort order requested is not supported";
    case ERROR_DS_NAME_NOT_UNIQUE                                                 : return "The requested name already exists as a unique identifier";
    case ERROR_DS_MACHINE_ACCOUNT_CREATED_PRENT4                                  : return "The machine account was created pre-NT4. The account needs to be recreated";
    case ERROR_DS_OUT_OF_VERSION_STORE                                            : return "The database is out of version store";
    case ERROR_DS_INCOMPATIBLE_CONTROLS_USED                                      : return "Unable to continue operation because multiple conflicting controls were used";
    case ERROR_DS_NO_REF_DOMAIN                                                   : return "Unable to find a valid security descriptor reference domain for this partition";
    case ERROR_DS_RESERVED_LINK_ID                                                : return "Schema update failed: The link identifier is reserved";
    case ERROR_DS_LINK_ID_NOT_AVAILABLE                                           : return "Schema update failed: There are no link identifiers available";
    case ERROR_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER                                   : return "An account group cannot have a universal group as a member";
    case ERROR_DS_MODIFYDN_DISALLOWED_BY_INSTANCE_TYPE                            : return "Rename or move operations on naming context heads or read-only objects are not allowed";
    case ERROR_DS_NO_OBJECT_MOVE_IN_SCHEMA_NC                                     : return "Move operations on objects in the schema naming context are not allowed";
    case ERROR_DS_MODIFYDN_DISALLOWED_BY_FLAG                                     : return "A system flag has been set on the object and does not allow the object to be moved or renamed";
    case ERROR_DS_MODIFYDN_WRONG_GRANDPARENT                                      : return "This object is not allowed to change its grandparent container. Moves are not forbidden on this object, but are restricted to sibling containers";
    case ERROR_DS_NAME_ERROR_TRUST_REFERRAL                                       : return "Unable to resolve completely, a referral to another forest is generated";
    case ERROR_NOT_SUPPORTED_ON_STANDARD_SERVER                                   : return "The requested action is not supported on standard server";
    case ERROR_DS_CANT_ACCESS_REMOTE_PART_OF_AD                                   : return "Could not access a partition of the directory service located on a remote server. Make sure at least one server is running for the partition in question";
    case ERROR_DS_CR_IMPOSSIBLE_TO_VALIDATE_V2                                    : return "The directory cannot validate the proposed naming context (or partition) name because it does not hold a replica nor can it contact a replica of the naming context above the proposed naming context. Please ensure that the parent naming context is properly registered in DNS, and at least one replica of this naming context is reachable by the Domain Naming master";
    case ERROR_DS_THREAD_LIMIT_EXCEEDED                                           : return "The thread limit for this request was exceeded";
    case ERROR_DS_NOT_CLOSEST                                                     : return "The Global catalog server is not in the closest site";
    case ERROR_DS_CANT_DERIVE_SPN_WITHOUT_SERVER_REF                              : return "The DS cannot derive a service principal name (SPN) with which to mutually authenticate the target server because the corresponding server object in the local DS database has no serverReference attribute";
    case ERROR_DS_SINGLE_USER_MODE_FAILED                                         : return "The Directory Service failed to enter single user mode";
    case ERROR_DS_NTDSCRIPT_SYNTAX_ERROR                                          : return "The Directory Service cannot parse the script because of a syntax error";
    case ERROR_DS_NTDSCRIPT_PROCESS_ERROR                                         : return "The Directory Service cannot process the script because of an error";
    case ERROR_DS_DIFFERENT_REPL_EPOCHS                                           : return "The directory service cannot perform the requested operation because the servers involved are of different replication epochs (which is usually related to a domain rename that is in progress)";
    case ERROR_DS_DRS_EXTENSIONS_CHANGED                                          : return "The directory service binding must be renegotiated due to a change in the server extensions information";
    case ERROR_DS_REPLICA_SET_CHANGE_NOT_ALLOWED_ON_DISABLED_CR                   : return "Operation not allowed on a disabled cross ref";
    case ERROR_DS_NO_MSDS_INTID                                                   : return "Schema update failed: No values for msDS-IntId are available";
    case ERROR_DS_DUP_MSDS_INTID                                                  : return "Schema update failed: Duplicate msDS-INtId. Retry the operation";
    case ERROR_DS_EXISTS_IN_RDNATTID                                              : return "Schema deletion failed: attribute is used in rDNAttID";
    case ERROR_DS_AUTHORIZATION_FAILED                                            : return "The directory service failed to authorize the request";
    case ERROR_DS_INVALID_SCRIPT                                                  : return "The Directory Service cannot process the script because it is invalid";
    case ERROR_DS_REMOTE_CROSSREF_OP_FAILED                                       : return "The remote create cross reference operation failed on the Domain Naming Master FSMO. The operation's error is in the extended data";
    case ERROR_DS_CROSS_REF_BUSY                                                  : return "A cross reference is in use locally with the same name";
    case ERROR_DS_CANT_DERIVE_SPN_FOR_DELETED_DOMAIN                              : return "The DS cannot derive a service principal name (SPN) with which to mutually authenticate the target server because the server's domain has been deleted from the forest";
    case ERROR_DS_CANT_DEMOTE_WITH_WRITEABLE_NC                                   : return "Writeable NCs prevent this DC from demoting";
    case ERROR_DS_DUPLICATE_ID_FOUND                                              : return "The requested object has a non-unique identifier and cannot be retrieved";
    case ERROR_DS_INSUFFICIENT_ATTR_TO_CREATE_OBJECT                              : return "Insufficient attributes were given to create an object. This object may not exist because it may have been deleted and already garbage collected";
    case ERROR_DS_GROUP_CONVERSION_ERROR                                          : return "The group cannot be converted due to attribute restrictions on the requested group type";
    case ERROR_DS_CANT_MOVE_APP_BASIC_GROUP                                       : return "Cross-domain move of non-empty basic application groups is not allowed";
    case ERROR_DS_CANT_MOVE_APP_QUERY_GROUP                                       : return "Cross-domain move of non-empty query based application groups is not allowed";
    case ERROR_DS_ROLE_NOT_VERIFIED                                               : return "The FSMO role ownership could not be verified because its directory partition has not replicated successfully with at least one replication partner";
    case ERROR_DS_WKO_CONTAINER_CANNOT_BE_SPECIAL                                 : return "The target container for a redirection of a well known object container cannot already be a special container";
    case ERROR_DS_DOMAIN_RENAME_IN_PROGRESS                                       : return "The Directory Service cannot perform the requested operation because a domain rename operation is in progress";
    case ERROR_DS_EXISTING_AD_CHILD_NC                                            : return "The directory service detected a child partition below the requested partition name. The partition hierarchy must be created in a top down method";
    case ERROR_DS_REPL_LIFETIME_EXCEEDED                                          : return "The directory service cannot replicate with this server because the time since the last replication with this server has exceeded the tombstone lifetime";
    case ERROR_DS_DISALLOWED_IN_SYSTEM_CONTAINER                                  : return "The requested operation is not allowed on an object under the system container";
    case ERROR_DS_LDAP_SEND_QUEUE_FULL                                            : return "The LDAP servers network send queue has filled up because the client is not processing the results of its requests fast enough. No more requests will be processed until the client catches up. If the client does not catch up then it will be disconnected";
    case ERROR_DS_DRA_OUT_SCHEDULE_WINDOW                                         : return "The scheduled replication did not take place because the system was too busy to execute the request within the schedule window. The replication queue is overloaded. Consider reducing the number of partners or decreasing the scheduled replication frequency";
    case ERROR_DS_POLICY_NOT_KNOWN                                                : return "At this time, it cannot be determined if the branch replication policy is available on the hub domain controller. Please retry at a later time to account for replication latencies";
    case ERROR_NO_SITE_SETTINGS_OBJECT                                            : return "The site settings object for the specified site does not exist";
    case ERROR_NO_SECRETS                                                         : return "The local account store does not contain secret material for the specified account";
    case ERROR_NO_WRITABLE_DC_FOUND                                               : return "Could not find a writable domain controller in the domain";
    case ERROR_DS_NO_SERVER_OBJECT                                                : return "The server object for the domain controller does not exist";
    case ERROR_DS_NO_NTDSA_OBJECT                                                 : return "The NTDS Settings object for the domain controller does not exist";
    case ERROR_DS_NON_ASQ_SEARCH                                                  : return "The requested search operation is not supported for ASQ searches";
    case ERROR_DS_AUDIT_FAILURE                                                   : return "A required audit event could not be generated for the operation";
    case ERROR_DS_INVALID_SEARCH_FLAG_SUBTREE                                     : return "The search flags for the attribute are invalid. The subtree index bit is valid only on single valued attributes";
    case ERROR_DS_INVALID_SEARCH_FLAG_TUPLE                                       : return "The search flags for the attribute are invalid. The tuple index bit is valid only on attributes of Unicode strings";
    case ERROR_DS_HIERARCHY_TABLE_TOO_DEEP                                        : return "The address books are nested too deeply. Failed to build the hierarchy table";
    case ERROR_DS_DRA_CORRUPT_UTD_VECTOR                                          : return "The specified up-to-date-ness vector is corrupt";
    case ERROR_DS_DRA_SECRETS_DENIED                                              : return "The request to replicate secrets is denied";
    case ERROR_DS_RESERVED_MAPI_ID                                                : return "Schema update failed: The MAPI identifier is reserved";
    case ERROR_DS_MAPI_ID_NOT_AVAILABLE                                           : return "Schema update failed: There are no MAPI identifiers available";
    case ERROR_DS_DRA_MISSING_KRBTGT_SECRET                                       : return "The replication operation failed because the required attributes of the local krbtgt object are missing";
    case ERROR_DS_DOMAIN_NAME_EXISTS_IN_FOREST                                    : return "The domain name of the trusted domain already exists in the forest";
    case ERROR_DS_FLAT_NAME_EXISTS_IN_FOREST                                      : return "The flat name of the trusted domain already exists in the forest";
    case ERROR_INVALID_USER_PRINCIPAL_NAME                                        : return "The User Principal Name (UPN) is invalid";
    case ERROR_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS                              : return "OID mapped groups cannot have members";
    case ERROR_DS_OID_NOT_FOUND                                                   : return "The specified OID cannot be found";
    case ERROR_DS_DRA_RECYCLED_TARGET                                             : return "The replication operation failed because the target object referred by a link value is recycled";
    case ERROR_DS_DISALLOWED_NC_REDIRECT                                          : return "The redirect operation failed because the target object is in a NC different from the domain NC of the current domain controller";
    case ERROR_DS_HIGH_ADLDS_FFL                                                  : return "The functional level of the AD LDS configuration set cannot be lowered to the requested value";
    case ERROR_DS_HIGH_DSA_VERSION                                                : return "The functional level of the domain (or forest) cannot be lowered to the requested value";
    case ERROR_DS_LOW_ADLDS_FFL                                                   : return "The functional level of the AD LDS configuration set cannot be raised to the requested value, because there exist one or more ADLDS instances that are at a lower incompatible functional level";
    case ERROR_DOMAIN_SID_SAME_AS_LOCAL_WORKSTATION                               : return "The domain join cannot be completed because the SID of the domain you attempted to join was identical to the SID of this machine. This is a symptom of an improperly cloned operating system install.  You should run sysprep on this machine in order to generate a new machine SID. Please see http://go.microsoft.com/fwlink/?LinkId=168895 for more information";
    case ERROR_DS_UNDELETE_SAM_VALIDATION_FAILED                                  : return "The undelete operation failed because the Sam Account Name or Additional Sam Account Name of the object being undeleted conflicts with an existing live object";
    case ERROR_INCORRECT_ACCOUNT_TYPE                                             : return "The system is not authoritative for the specified account and therefore cannot complete the operation. Please retry the operation using the provider associated with this account. If this is an online provider please use the provider's online site";
    case ERROR_DS_SPN_VALUE_NOT_UNIQUE_IN_FOREST                                  : return "The operation failed because SPN value provided for addition/modification is not unique forest-wide";
    case ERROR_DS_UPN_VALUE_NOT_UNIQUE_IN_FOREST                                  : return "The operation failed because UPN value provided for addition/modification is not unique forest-wide";
    case ERROR_DS_MISSING_FOREST_TRUST                                            : return "The operation failed because the addition/modification referenced an inbound forest-wide trust that is not present";
    case ERROR_DS_VALUE_KEY_NOT_UNIQUE                                            : return "The link value specified was not found, but a link value with that key was found";
    case DNS_ERROR_RCODE_FORMAT_ERROR                                             : return "DNS server unable to interpret format";
    case DNS_ERROR_RCODE_SERVER_FAILURE                                           : return "DNS server failure";
    case DNS_ERROR_RCODE_NAME_ERROR                                               : return "DNS name does not exist";
    case DNS_ERROR_RCODE_NOT_IMPLEMENTED                                          : return "DNS request not supported by name server";
    case DNS_ERROR_RCODE_REFUSED                                                  : return "DNS operation refused";
    case DNS_ERROR_RCODE_YXDOMAIN                                                 : return "DNS name that ought not exist, does exist";
    case DNS_ERROR_RCODE_YXRRSET                                                  : return "DNS RR set that ought not exist, does exist";
    case DNS_ERROR_RCODE_NXRRSET                                                  : return "DNS RR set that ought to exist, does not exist";
    case DNS_ERROR_RCODE_NOTAUTH                                                  : return "DNS server not authoritative for zone";
    case DNS_ERROR_RCODE_NOTZONE                                                  : return "DNS name in update or prereq is not in zone";
    case DNS_ERROR_RCODE_BADSIG                                                   : return "DNS signature failed to verify";
    case DNS_ERROR_RCODE_BADKEY                                                   : return "DNS bad key";
    case DNS_ERROR_RCODE_BADTIME                                                  : return "DNS signature validity expired";
    case DNS_ERROR_KEYMASTER_REQUIRED                                             : return "Only the DNS server acting as the key master for the zone may perform this operation";
    case DNS_ERROR_NOT_ALLOWED_ON_SIGNED_ZONE                                     : return "This operation is not allowed on a zone that is signed or has signing keys";
    case DNS_ERROR_NSEC3_INCOMPATIBLE_WITH_RSA_SHA1                               : return "NSEC3 is not compatible with the RSA-SHA-1 algorithm. Choose a different algorithm or use NSEC";
    case DNS_ERROR_NOT_ENOUGH_SIGNING_KEY_DESCRIPTORS                             : return "The zone does not have enough signing keys. There must be at least one key signing key (KSK) and at least one zone signing key (ZSK)";
    case DNS_ERROR_UNSUPPORTED_ALGORITHM                                          : return "The specified algorithm is not supported";
    case DNS_ERROR_INVALID_KEY_SIZE                                               : return "The specified key size is not supported";
    case DNS_ERROR_SIGNING_KEY_NOT_ACCESSIBLE                                     : return "One or more of the signing keys for a zone are not accessible to the DNS server. Zone signing will not be operational until this error is resolved";
    case DNS_ERROR_KSP_DOES_NOT_SUPPORT_PROTECTION                                : return "The specified key storage provider does not support DPAPI++ data protection. Zone signing will not be operational until this error is resolved";
    case DNS_ERROR_UNEXPECTED_DATA_PROTECTION_ERROR                               : return "An unexpected DPAPI++ error was encountered. Zone signing will not be operational until this error is resolved";
    case DNS_ERROR_UNEXPECTED_CNG_ERROR                                           : return "An unexpected crypto error was encountered. Zone signing may not be operational until this error is resolved";
    case DNS_ERROR_UNKNOWN_SIGNING_PARAMETER_VERSION                              : return "The DNS server encountered a signing key with an unknown version. Zone signing will not be operational until this error is resolved";
    case DNS_ERROR_KSP_NOT_ACCESSIBLE                                             : return "The specified key service provider cannot be opened by the DNS server";
    case DNS_ERROR_TOO_MANY_SKDS                                                  : return "The DNS server cannot accept any more signing keys with the specified algorithm and KSK flag value for this zone";
    case DNS_ERROR_INVALID_ROLLOVER_PERIOD                                        : return "The specified rollover period is invalid";
    case DNS_ERROR_INVALID_INITIAL_ROLLOVER_OFFSET                                : return "The specified initial rollover offset is invalid";
    case DNS_ERROR_ROLLOVER_IN_PROGRESS                                           : return "The specified signing key is already in process of rolling over keys";
    case DNS_ERROR_STANDBY_KEY_NOT_PRESENT                                        : return "The specified signing key does not have a standby key to revoke";
    case DNS_ERROR_NOT_ALLOWED_ON_ZSK                                             : return "This operation is not allowed on a zone signing key (ZSK)";
    case DNS_ERROR_NOT_ALLOWED_ON_ACTIVE_SKD                                      : return "This operation is not allowed on an active signing key";
    case DNS_ERROR_ROLLOVER_ALREADY_QUEUED                                        : return "The specified signing key is already queued for rollover";
    case DNS_ERROR_NOT_ALLOWED_ON_UNSIGNED_ZONE                                   : return "This operation is not allowed on an unsigned zone";
    case DNS_ERROR_BAD_KEYMASTER                                                  : return "This operation could not be completed because the DNS server listed as the current key master for this zone is down or misconfigured. Resolve the problem on the current key master for this zone or use another DNS server to seize the key master role";
    case DNS_ERROR_INVALID_SIGNATURE_VALIDITY_PERIOD                              : return "The specified signature validity period is invalid";
    case DNS_ERROR_INVALID_NSEC3_ITERATION_COUNT                                  : return "The specified NSEC3 iteration count is higher than allowed by the minimum key length used in the zone";
    case DNS_ERROR_DNSSEC_IS_DISABLED                                             : return "This operation could not be completed because the DNS server has been configured with DNSSEC features disabled. Enable DNSSEC on the DNS server";
    case DNS_ERROR_INVALID_XML                                                    : return "This operation could not be completed because the XML stream received is empty or syntactically invalid";
    case DNS_ERROR_NO_VALID_TRUST_ANCHORS                                         : return "This operation completed, but no trust anchors were added because all of the trust anchors received were either invalid, unsupported, expired, or would not become valid in less than 30 days";
    case DNS_ERROR_ROLLOVER_NOT_POKEABLE                                          : return "The specified signing key is not waiting for parental DS update";
    case DNS_ERROR_NSEC3_NAME_COLLISION                                           : return "Hash collision detected during NSEC3 signing. Specify a different user-provided salt, or use a randomly generated salt, and attempt to sign the zone again";
    case DNS_ERROR_NSEC_INCOMPATIBLE_WITH_NSEC3_RSA_SHA1                          : return "NSEC is not compatible with the NSEC3-RSA-SHA-1 algorithm. Choose a different algorithm or use NSEC3";
    case DNS_INFO_NO_RECORDS                                                      : return "No records found for given DNS query";
    case DNS_ERROR_BAD_PACKET                                                     : return "Bad DNS packet";
    case DNS_ERROR_NO_PACKET                                                      : return "No DNS packet";
    case DNS_ERROR_RCODE                                                          : return "DNS error, check rcode";
    case DNS_ERROR_UNSECURE_PACKET                                                : return "Unsecured DNS packet";
    case DNS_REQUEST_PENDING                                                      : return "DNS query request is pending";
    case DNS_ERROR_INVALID_TYPE                                                   : return "Invalid DNS type";
    case DNS_ERROR_INVALID_IP_ADDRESS                                             : return "Invalid IP address";
    case DNS_ERROR_INVALID_PROPERTY                                               : return "Invalid property";
    case DNS_ERROR_TRY_AGAIN_LATER                                                : return "Try DNS operation again later";
    case DNS_ERROR_NOT_UNIQUE                                                     : return "Record for given name and type is not unique";
    case DNS_ERROR_NON_RFC_NAME                                                   : return "DNS name does not comply with RFC specifications";
    case DNS_STATUS_FQDN                                                          : return "DNS name is a fully-qualified DNS name";
    case DNS_STATUS_DOTTED_NAME                                                   : return "DNS name is dotted (multi-label)";
    case DNS_STATUS_SINGLE_PART_NAME                                              : return "DNS name is a single-part name";
    case DNS_ERROR_INVALID_NAME_CHAR                                              : return "DNS name contains an invalid character";
    case DNS_ERROR_NUMERIC_NAME                                                   : return "DNS name is entirely numeric";
    case DNS_ERROR_NOT_ALLOWED_ON_ROOT_SERVER                                     : return "The operation requested is not permitted on a DNS root server";
    case DNS_ERROR_NOT_ALLOWED_UNDER_DELEGATION                                   : return "The record could not be created because this part of the DNS namespace has been delegated to another server";
    case DNS_ERROR_CANNOT_FIND_ROOT_HINTS                                         : return "The DNS server could not find a set of root hints";
    case DNS_ERROR_INCONSISTENT_ROOT_HINTS                                        : return "The DNS server found root hints but they were not consistent across all adapters";
    case DNS_ERROR_DWORD_VALUE_TOO_SMALL                                          : return "The specified value is too small for this parameter";
    case DNS_ERROR_DWORD_VALUE_TOO_LARGE                                          : return "The specified value is too large for this parameter";
    case DNS_ERROR_BACKGROUND_LOADING                                             : return "This operation is not allowed while the DNS server is loading zones in the background. Please try again later";
    case DNS_ERROR_NOT_ALLOWED_ON_RODC                                            : return "The operation requested is not permitted on against a DNS server running on a read-only DC";
    case DNS_ERROR_NOT_ALLOWED_UNDER_DNAME                                        : return "No data is allowed to exist underneath a DNAME record";
    case DNS_ERROR_DELEGATION_REQUIRED                                            : return "This operation requires credentials delegation";
    case DNS_ERROR_INVALID_POLICY_TABLE                                           : return "Name resolution policy table has been corrupted. DNS resolution will fail until it is fixed. Contact your network administrator";
    case DNS_ERROR_ADDRESS_REQUIRED                                               : return "Not allowed to remove all addresses";
    case DNS_ERROR_ZONE_DOES_NOT_EXIST                                            : return "DNS zone does not exist";
    case DNS_ERROR_NO_ZONE_INFO                                                   : return "DNS zone information not available";
    case DNS_ERROR_INVALID_ZONE_OPERATION                                         : return "Invalid operation for DNS zone";
    case DNS_ERROR_ZONE_CONFIGURATION_ERROR                                       : return "Invalid DNS zone configuration";
    case DNS_ERROR_ZONE_HAS_NO_SOA_RECORD                                         : return "DNS zone has no start of authority (SOA) record";
    case DNS_ERROR_ZONE_HAS_NO_NS_RECORDS                                         : return "DNS zone has no Name Server (NS) record";
    case DNS_ERROR_ZONE_LOCKED                                                    : return "DNS zone is locked";
    case DNS_ERROR_ZONE_CREATION_FAILED                                           : return "DNS zone creation failed";
    case DNS_ERROR_ZONE_ALREADY_EXISTS                                            : return "DNS zone already exists";
    case DNS_ERROR_AUTOZONE_ALREADY_EXISTS                                        : return "DNS automatic zone already exists";
    case DNS_ERROR_INVALID_ZONE_TYPE                                              : return "Invalid DNS zone type";
    case DNS_ERROR_SECONDARY_REQUIRES_MASTER_IP                                   : return "Secondary DNS zone requires master IP address";
    case DNS_ERROR_ZONE_NOT_SECONDARY                                             : return "DNS zone not secondary";
    case DNS_ERROR_NEED_SECONDARY_ADDRESSES                                       : return "Need secondary IP address";
    case DNS_ERROR_WINS_INIT_FAILED                                               : return "WINS initialization failed";
    case DNS_ERROR_NEED_WINS_SERVERS                                              : return "Need WINS servers";
    case DNS_ERROR_NBSTAT_INIT_FAILED                                             : return "NBTSTAT initialization call failed";
    case DNS_ERROR_SOA_DELETE_INVALID                                             : return "Invalid delete of start of authority (SOA)";
    case DNS_ERROR_FORWARDER_ALREADY_EXISTS                                       : return "A conditional forwarding zone already exists for that name";
    case DNS_ERROR_ZONE_REQUIRES_MASTER_IP                                        : return "This zone must be configured with one or more master DNS server IP addresses";
    case DNS_ERROR_ZONE_IS_SHUTDOWN                                               : return "The operation cannot be performed because this zone is shut down";
    case DNS_ERROR_ZONE_LOCKED_FOR_SIGNING                                        : return "This operation cannot be performed because the zone is currently being signed. Please try again later";
    case DNS_ERROR_PRIMARY_REQUIRES_DATAFILE                                      : return "Primary DNS zone requires datafile";
    case DNS_ERROR_INVALID_DATAFILE_NAME                                          : return "Invalid datafile name for DNS zone";
    case DNS_ERROR_DATAFILE_OPEN_FAILURE                                          : return "Failed to open datafile for DNS zone";
    case DNS_ERROR_FILE_WRITEBACK_FAILED                                          : return "Failed to write datafile for DNS zone";
    case DNS_ERROR_DATAFILE_PARSING                                               : return "Failure while reading datafile for DNS zone";
    case DNS_ERROR_RECORD_DOES_NOT_EXIST                                          : return "DNS record does not exist";
    case DNS_ERROR_RECORD_FORMAT                                                  : return "DNS record format error";
    case DNS_ERROR_NODE_CREATION_FAILED                                           : return "Node creation failure in DNS";
    case DNS_ERROR_UNKNOWN_RECORD_TYPE                                            : return "Unknown DNS record type";
    case DNS_ERROR_RECORD_TIMED_OUT                                               : return "DNS record timed out";
    case DNS_ERROR_NAME_NOT_IN_ZONE                                               : return "Name not in DNS zone";
    case DNS_ERROR_CNAME_LOOP                                                     : return "CNAME loop detected";
    case DNS_ERROR_NODE_IS_CNAME                                                  : return "Node is a CNAME DNS record";
    case DNS_ERROR_CNAME_COLLISION                                                : return "A CNAME record already exists for given name";
    case DNS_ERROR_RECORD_ONLY_AT_ZONE_ROOT                                       : return "Record only at DNS zone root";
    case DNS_ERROR_RECORD_ALREADY_EXISTS                                          : return "DNS record already exists";
    case DNS_ERROR_SECONDARY_DATA                                                 : return "Secondary DNS zone data error";
    case DNS_ERROR_NO_CREATE_CACHE_DATA                                           : return "Could not create DNS cache data";
    case DNS_ERROR_NAME_DOES_NOT_EXIST                                            : return "DNS name does not exist";
    case DNS_WARNING_PTR_CREATE_FAILED                                            : return "Could not create pointer (PTR) record";
    case DNS_WARNING_DOMAIN_UNDELETED                                             : return "DNS domain was undeleted";
    case DNS_ERROR_DS_UNAVAILABLE                                                 : return "The directory service is unavailable";
    case DNS_ERROR_DS_ZONE_ALREADY_EXISTS                                         : return "DNS zone already exists in the directory service";
    case DNS_ERROR_NO_BOOTFILE_IF_DS_ZONE                                         : return "DNS server not creating or reading the boot file for the directory service integrated DNS zone";
    case DNS_ERROR_NODE_IS_DNAME                                                  : return "Node is a DNAME DNS record";
    case DNS_ERROR_DNAME_COLLISION                                                : return "A DNAME record already exists for given name";
    case DNS_ERROR_ALIAS_LOOP                                                     : return "An alias loop has been detected with either CNAME or DNAME records";
    case DNS_INFO_AXFR_COMPLETE                                                   : return "DNS AXFR (zone transfer) complete";
    case DNS_ERROR_AXFR                                                           : return "DNS zone transfer failed";
    case DNS_INFO_ADDED_LOCAL_WINS                                                : return "Added local WINS server";
    case DNS_STATUS_CONTINUE_NEEDED                                               : return "Secure update call needs to continue update request";
    case DNS_ERROR_NO_TCPIP                                                       : return "TCP/IP network protocol not installed";
    case DNS_ERROR_NO_DNS_SERVERS                                                 : return "No DNS servers configured for local system";
    case DNS_ERROR_DP_DOES_NOT_EXIST                                              : return "The specified directory partition does not exist";
    case DNS_ERROR_DP_ALREADY_EXISTS                                              : return "The specified directory partition already exists";
    case DNS_ERROR_DP_NOT_ENLISTED                                                : return "This DNS server is not enlisted in the specified directory partition";
    case DNS_ERROR_DP_ALREADY_ENLISTED                                            : return "This DNS server is already enlisted in the specified directory partition";
    case DNS_ERROR_DP_NOT_AVAILABLE                                               : return "The directory partition is not available at this time. Please wait a few minutes and try again";
    case DNS_ERROR_DP_FSMO_ERROR                                                  : return "The operation failed because the domain naming master FSMO role could not be reached. The domain controller holding the domain naming master FSMO role is down or unable to service the request or is not running Windows Server 2003 or later";
    case DNS_ERROR_RRL_NOT_ENABLED                                                : return "The RRL is not enabled";
    case DNS_ERROR_RRL_INVALID_WINDOW_SIZE                                        : return "The window size parameter is invalid. It should be greater than or equal to 1";
    case DNS_ERROR_RRL_INVALID_IPV4_PREFIX                                        : return "The IPv4 prefix length parameter is invalid. It should be less than or equal to 32";
    case DNS_ERROR_RRL_INVALID_IPV6_PREFIX                                        : return "The IPv6 prefix length parameter is invalid. It should be less than or equal to 128";
    case DNS_ERROR_RRL_INVALID_TC_RATE                                            : return "The TC Rate parameter is invalid. It should be less than 10";
    case DNS_ERROR_RRL_INVALID_LEAK_RATE                                          : return "The Leak Rate parameter is invalid. It should be either 0, or between 2 and 10";
    case DNS_ERROR_RRL_LEAK_RATE_LESSTHAN_TC_RATE                                 : return "The Leak Rate or TC Rate parameter is invalid. Leak Rate should be greater than TC Rate";
    case DNS_ERROR_VIRTUALIZATION_INSTANCE_ALREADY_EXISTS                         : return "The virtualization instance already exists";
    case DNS_ERROR_VIRTUALIZATION_INSTANCE_DOES_NOT_EXIST                         : return "The virtualization instance does not exist";
    case DNS_ERROR_VIRTUALIZATION_TREE_LOCKED                                     : return "The virtualization tree is locked";
    case DNS_ERROR_INVAILD_VIRTUALIZATION_INSTANCE_NAME                           : return "Invalid virtualization instance name";
    case DNS_ERROR_DEFAULT_VIRTUALIZATION_INSTANCE                                : return "The default virtualization instance cannot be added, removed or modified";
    case DNS_ERROR_ZONESCOPE_ALREADY_EXISTS                                       : return "The scope already exists for the zone";
    case DNS_ERROR_ZONESCOPE_DOES_NOT_EXIST                                       : return "The scope does not exist for the zone";
    case DNS_ERROR_DEFAULT_ZONESCOPE                                              : return "The scope is the same as the default zone scope";
    case DNS_ERROR_INVALID_ZONESCOPE_NAME                                         : return "The scope name contains invalid characters";
    case DNS_ERROR_NOT_ALLOWED_WITH_ZONESCOPES                                    : return "Operation not allowed when the zone has scopes";
    case DNS_ERROR_LOAD_ZONESCOPE_FAILED                                          : return "Failed to load zone scope";
    case DNS_ERROR_ZONESCOPE_FILE_WRITEBACK_FAILED                                : return "Failed to write data file for DNS zone scope. Please verify the file exists and is writable";
    case DNS_ERROR_INVALID_SCOPE_NAME                                             : return "The scope name contains invalid characters";
    case DNS_ERROR_SCOPE_DOES_NOT_EXIST                                           : return "The scope does not exist";
    case DNS_ERROR_DEFAULT_SCOPE                                                  : return "The scope is the same as the default scope";
    case DNS_ERROR_INVALID_SCOPE_OPERATION                                        : return "The operation is invalid on the scope";
    case DNS_ERROR_SCOPE_LOCKED                                                   : return "The scope is locked";
    case DNS_ERROR_SCOPE_ALREADY_EXISTS                                           : return "The scope already exists";
    case DNS_ERROR_POLICY_ALREADY_EXISTS                                          : return "A policy with the same name already exists on this level (server level or zone level) on the DNS server";
    case DNS_ERROR_POLICY_DOES_NOT_EXIST                                          : return "No policy with this name exists on this level (server level or zone level) on the DNS server";
    case DNS_ERROR_POLICY_INVALID_CRITERIA                                        : return "The criteria provided in the policy are invalid";
    case DNS_ERROR_POLICY_INVALID_SETTINGS                                        : return "At least one of the settings of this policy is invalid";
    case DNS_ERROR_CLIENT_SUBNET_IS_ACCESSED                                      : return "The client subnet cannot be deleted while it is being accessed by a policy";
    case DNS_ERROR_CLIENT_SUBNET_DOES_NOT_EXIST                                   : return "The client subnet does not exist on the DNS server";
    case DNS_ERROR_CLIENT_SUBNET_ALREADY_EXISTS                                   : return "A client subnet with this name already exists on the DNS server";
    case DNS_ERROR_SUBNET_DOES_NOT_EXIST                                          : return "The IP subnet specified does not exist in the client subnet";
    case DNS_ERROR_SUBNET_ALREADY_EXISTS                                          : return "The IP subnet that is being added, already exists in the client subnet";
    case DNS_ERROR_POLICY_LOCKED                                                  : return "The policy is locked";
    case DNS_ERROR_POLICY_INVALID_WEIGHT                                          : return "The weight of the scope in the policy is invalid";
    case DNS_ERROR_POLICY_INVALID_NAME                                            : return "The DNS policy name is invalid";
    case DNS_ERROR_POLICY_MISSING_CRITERIA                                        : return "The policy is missing criteria";
    case DNS_ERROR_INVALID_CLIENT_SUBNET_NAME                                     : return "The name of the the client subnet record is invalid";
    case DNS_ERROR_POLICY_PROCESSING_ORDER_INVALID                                : return "Invalid policy processing order";
    case DNS_ERROR_POLICY_SCOPE_MISSING                                           : return "The scope information has not been provided for a policy that requires it";
    case DNS_ERROR_POLICY_SCOPE_NOT_ALLOWED                                       : return "The scope information has been provided for a policy that does not require it";
    case DNS_ERROR_SERVERSCOPE_IS_REFERENCED                                      : return "The server scope cannot be deleted because it is referenced by a DNS Policy";
    case DNS_ERROR_ZONESCOPE_IS_REFERENCED                                        : return "The zone scope cannot be deleted because it is referenced by a DNS Policy";
    case DNS_ERROR_POLICY_INVALID_CRITERIA_CLIENT_SUBNET                          : return "The criterion client subnet provided in the policy is invalid";
    case DNS_ERROR_POLICY_INVALID_CRITERIA_TRANSPORT_PROTOCOL                     : return "The criterion transport protocol provided in the policy is invalid";
    case DNS_ERROR_POLICY_INVALID_CRITERIA_NETWORK_PROTOCOL                       : return "The criterion network protocol provided in the policy is invalid";
    case DNS_ERROR_POLICY_INVALID_CRITERIA_INTERFACE                              : return "The criterion interface provided in the policy is invalid";
    case DNS_ERROR_POLICY_INVALID_CRITERIA_FQDN                                   : return "The criterion FQDN provided in the policy is invalid";
    case DNS_ERROR_POLICY_INVALID_CRITERIA_QUERY_TYPE                             : return "The criterion query type provided in the policy is invalid";
    case DNS_ERROR_POLICY_INVALID_CRITERIA_TIME_OF_DAY                            : return "The criterion time of day provided in the policy is invalid";
    case WSAEINTR                                                                 : return "A blocking operation was interrupted by a call to WSACancelBlockingCall";
    case WSAEBADF                                                                 : return "The file handle supplied is not valid";
    case WSAEACCES                                                                : return "An attempt was made to access a socket in a way forbidden by its access permissions";
    case WSAEFAULT                                                                : return "The system detected an invalid pointer address in attempting to use a pointer argument in a call";
    case WSAEINVAL                                                                : return "An invalid argument was supplied";
    case WSAEMFILE                                                                : return "Too many open sockets";
    case WSAEWOULDBLOCK                                                           : return "A non-blocking socket operation could not be completed immediately";
    case WSAEINPROGRESS                                                           : return "A blocking operation is currently executing";
    case WSAEALREADY                                                              : return "An operation was attempted on a non-blocking socket that already had an operation in progress";
    case WSAENOTSOCK                                                              : return "An operation was attempted on something that is not a socket";
    case WSAEDESTADDRREQ                                                          : return "A required address was omitted from an operation on a socket";
    case WSAEMSGSIZE                                                              : return "A message sent on a datagram socket was larger than the internal message buffer or some other network limit, or the buffer used to receive a datagram into was smaller than the datagram itself";
    case WSAEPROTOTYPE                                                            : return "A protocol was specified in the socket function call that does not support the semantics of the socket type requested";
    case WSAENOPROTOOPT                                                           : return "An unknown, invalid, or unsupported option or level was specified in a getsockopt or setsockopt call";
    case WSAEPROTONOSUPPORT                                                       : return "The requested protocol has not been configured into the system, or no implementation for it exists";
    case WSAESOCKTNOSUPPORT                                                       : return "The support for the specified socket type does not exist in this address family";
    case WSAEOPNOTSUPP                                                            : return "The attempted operation is not supported for the type of object referenced";
    case WSAEPFNOSUPPORT                                                          : return "The protocol family has not been configured into the system or no implementation for it exists";
    case WSAEAFNOSUPPORT                                                          : return "An address incompatible with the requested protocol was used";
    case WSAEADDRINUSE                                                            : return "Only one usage of each socket address (protocol/network address/port) is normally permitted";
    case WSAEADDRNOTAVAIL                                                         : return "The requested address is not valid in its context";
    case WSAENETDOWN                                                              : return "A socket operation encountered a dead network";
    case WSAENETUNREACH                                                           : return "A socket operation was attempted to an unreachable network";
    case WSAENETRESET                                                             : return "The connection has been broken due to keep-alive activity detecting a failure while the operation was in progress";
    case WSAECONNABORTED                                                          : return "An established connection was aborted by the software in your host machine";
    case WSAECONNRESET                                                            : return "An existing connection was forcibly closed by the remote host";
    case WSAENOBUFS                                                               : return "An operation on a socket could not be performed because the system lacked sufficient buffer space or because a queue was full";
    case WSAEISCONN                                                               : return "A connect request was made on an already connected socket";
    case WSAENOTCONN                                                              : return "A request to send or receive data was disallowed because the socket is not connected and (when sending on a datagram socket using a sendto call) no address was supplied";
    case WSAESHUTDOWN                                                             : return "A request to send or receive data was disallowed because the socket had already been shut down in that direction with a previous shutdown call";
    case WSAETOOMANYREFS                                                          : return "Too many references to some kernel object";
    case WSAETIMEDOUT                                                             : return "A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond";
    case WSAECONNREFUSED                                                          : return "No connection could be made because the target machine actively refused it";
    case WSAELOOP                                                                 : return "Cannot translate name";
    case WSAENAMETOOLONG                                                          : return "Name component or name was too long";
    case WSAEHOSTDOWN                                                             : return "A socket operation failed because the destination host was down";
    case WSAEHOSTUNREACH                                                          : return "A socket operation was attempted to an unreachable host";
    case WSAENOTEMPTY                                                             : return "Cannot remove a directory that is not empty";
    case WSAEPROCLIM                                                              : return "A Windows Sockets implementation may have a limit on the number of applications that may use it simultaneously";
    case WSAEUSERS                                                                : return "Ran out of quota";
    case WSAEDQUOT                                                                : return "Ran out of disk quota";
    case WSAESTALE                                                                : return "File handle reference is no longer available";
    case WSAEREMOTE                                                               : return "Item is not available locally";
    case WSASYSNOTREADY                                                           : return "WSAStartup cannot function at this time because the underlying system it uses to provide network services is currently unavailable";
    case WSAVERNOTSUPPORTED                                                       : return "The Windows Sockets version requested is not supported";
    case WSANOTINITIALISED                                                        : return "Either the application has not called WSAStartup, or WSAStartup failed";
    case WSAEDISCON                                                               : return "Returned by WSARecv or WSARecvFrom to indicate the remote party has initiated a graceful shutdown sequence";
    case WSAENOMORE                                                               : return "No more results can be returned by WSALookupServiceNext";
    case WSAECANCELLED                                                            : return "A call to WSALookupServiceEnd was made while this call was still processing. The call has been canceled";
    case WSAEINVALIDPROCTABLE                                                     : return "The procedure call table is invalid";
    case WSAEINVALIDPROVIDER                                                      : return "The requested service provider is invalid";
    case WSAEPROVIDERFAILEDINIT                                                   : return "The requested service provider could not be loaded or initialized";
    case WSASYSCALLFAILURE                                                        : return "A system call has failed";
    case WSASERVICE_NOT_FOUND                                                     : return "No such service is known. The service cannot be found in the specified name space";
    case WSATYPE_NOT_FOUND                                                        : return "The specified class was not found";
    case WSA_E_NO_MORE                                                            : return "No more results can be returned by WSALookupServiceNext";
    case WSA_E_CANCELLED                                                          : return "A call to WSALookupServiceEnd was made while this call was still processing. The call has been canceled";
    case WSAEREFUSED                                                              : return "A database query failed because it was actively refused";
    case WSAHOST_NOT_FOUND                                                        : return "No such host is known";
    case WSATRY_AGAIN                                                             : return "This is usually a temporary error during hostname resolution and means that the local server did not receive a response from an authoritative server";
    case WSANO_RECOVERY                                                           : return "A non-recoverable error occurred during a database lookup";
    case WSANO_DATA                                                               : return "The requested name is valid, but no data of the requested type was found";
    case WSA_QOS_RECEIVERS                                                        : return "At least one reserve has arrived";
    case WSA_QOS_SENDERS                                                          : return "At least one path has arrived";
    case WSA_QOS_NO_SENDERS                                                       : return "There are no senders";
    case WSA_QOS_NO_RECEIVERS                                                     : return "There are no receivers";
    case WSA_QOS_REQUEST_CONFIRMED                                                : return "Reserve has been confirmed";
    case WSA_QOS_ADMISSION_FAILURE                                                : return "Error due to lack of resources";
    case WSA_QOS_POLICY_FAILURE                                                   : return "Rejected for administrative reasons - bad credentials";
    case WSA_QOS_BAD_STYLE                                                        : return "Unknown or conflicting style";
    case WSA_QOS_BAD_OBJECT                                                       : return "Problem with some part of the filterspec or providerspecific buffer in general";
    case WSA_QOS_TRAFFIC_CTRL_ERROR                                               : return "Problem with some part of the flowspec";
    case WSA_QOS_GENERIC_ERROR                                                    : return "General QOS error";
    case WSA_QOS_ESERVICETYPE                                                     : return "An invalid or unrecognized service type was found in the flowspec";
    case WSA_QOS_EFLOWSPEC                                                        : return "An invalid or inconsistent flowspec was found in the QOS structure";
    case WSA_QOS_EPROVSPECBUF                                                     : return "Invalid QOS provider-specific buffer";
    case WSA_QOS_EFILTERSTYLE                                                     : return "An invalid QOS filter style was used";
    case WSA_QOS_EFILTERTYPE                                                      : return "An invalid QOS filter type was used";
    case WSA_QOS_EFILTERCOUNT                                                     : return "An incorrect number of QOS FILTERSPECs were specified in the FLOWDESCRIPTOR";
    case WSA_QOS_EOBJLENGTH                                                       : return "An object with an invalid ObjectLength field was specified in the QOS provider-specific buffer";
    case WSA_QOS_EFLOWCOUNT                                                       : return "An incorrect number of flow descriptors was specified in the QOS structure";
    case WSA_QOS_EUNKOWNPSOBJ                                                     : return "An unrecognized object was found in the QOS provider-specific buffer";
    case WSA_QOS_EPOLICYOBJ                                                       : return "An invalid policy object was found in the QOS provider-specific buffer";
    case WSA_QOS_EFLOWDESC                                                        : return "An invalid QOS flow descriptor was found in the flow descriptor list";
    case WSA_QOS_EPSFLOWSPEC                                                      : return "An invalid or inconsistent flowspec was found in the QOS provider specific buffer";
    case WSA_QOS_EPSFILTERSPEC                                                    : return "An invalid FILTERSPEC was found in the QOS provider-specific buffer";
    case WSA_QOS_ESDMODEOBJ                                                       : return "An invalid shape discard mode object was found in the QOS provider specific buffer";
    case WSA_QOS_ESHAPERATEOBJ                                                    : return "An invalid shaping rate object was found in the QOS provider-specific buffer";
    case WSA_QOS_RESERVED_PETYPE                                                  : return "A reserved policy element was found in the QOS provider-specific buffer";
    case WSA_SECURE_HOST_NOT_FOUND                                                : return "No such host is known securely";
    case WSA_IPSEC_NAME_POLICY_ERROR                                              : return "Name based IPSEC policy could not be added";
    case ERROR_IPSEC_QM_POLICY_EXISTS                                             : return "The specified quick mode policy already exists";
    case ERROR_IPSEC_QM_POLICY_NOT_FOUND                                          : return "The specified quick mode policy was not found";
    case ERROR_IPSEC_QM_POLICY_IN_USE                                             : return "The specified quick mode policy is being used";
    case ERROR_IPSEC_MM_POLICY_EXISTS                                             : return "The specified main mode policy already exists";
    case ERROR_IPSEC_MM_POLICY_NOT_FOUND                                          : return "The specified main mode policy was not found";
    case ERROR_IPSEC_MM_POLICY_IN_USE                                             : return "The specified main mode policy is being used";
    case ERROR_IPSEC_MM_FILTER_EXISTS                                             : return "The specified main mode filter already exists";
    case ERROR_IPSEC_MM_FILTER_NOT_FOUND                                          : return "The specified main mode filter was not found";
    case ERROR_IPSEC_TRANSPORT_FILTER_EXISTS                                      : return "The specified transport mode filter already exists";
    case ERROR_IPSEC_TRANSPORT_FILTER_NOT_FOUND                                   : return "The specified transport mode filter does not exist";
    case ERROR_IPSEC_MM_AUTH_EXISTS                                               : return "The specified main mode authentication list exists";
    case ERROR_IPSEC_MM_AUTH_NOT_FOUND                                            : return "The specified main mode authentication list was not found";
    case ERROR_IPSEC_MM_AUTH_IN_USE                                               : return "The specified main mode authentication list is being used";
    case ERROR_IPSEC_DEFAULT_MM_POLICY_NOT_FOUND                                  : return "The specified default main mode policy was not found";
    case ERROR_IPSEC_DEFAULT_MM_AUTH_NOT_FOUND                                    : return "The specified default main mode authentication list was not found";
    case ERROR_IPSEC_DEFAULT_QM_POLICY_NOT_FOUND                                  : return "The specified default quick mode policy was not found";
    case ERROR_IPSEC_TUNNEL_FILTER_EXISTS                                         : return "The specified tunnel mode filter exists";
    case ERROR_IPSEC_TUNNEL_FILTER_NOT_FOUND                                      : return "The specified tunnel mode filter was not found";
    case ERROR_IPSEC_MM_FILTER_PENDING_DELETION                                   : return "The Main Mode filter is pending deletion";
    case ERROR_IPSEC_TRANSPORT_FILTER_PENDING_DELETION                            : return "The transport filter is pending deletion";
    case ERROR_IPSEC_TUNNEL_FILTER_PENDING_DELETION                               : return "The tunnel filter is pending deletion";
    case ERROR_IPSEC_MM_POLICY_PENDING_DELETION                                   : return "The Main Mode policy is pending deletion";
    case ERROR_IPSEC_MM_AUTH_PENDING_DELETION                                     : return "The Main Mode authentication bundle is pending deletion";
    case ERROR_IPSEC_QM_POLICY_PENDING_DELETION                                   : return "The Quick Mode policy is pending deletion";
    case WARNING_IPSEC_MM_POLICY_PRUNED                                           : return "The Main Mode policy was successfully added, but some of the requested offers are not supported";
    case WARNING_IPSEC_QM_POLICY_PRUNED                                           : return "The Quick Mode policy was successfully added, but some of the requested offers are not supported";
    case ERROR_IPSEC_IKE_NEG_STATUS_BEGIN                                         : return "ERROR_IPSEC_IKE_NEG_STATUS_BEGIN";
    case ERROR_IPSEC_IKE_AUTH_FAIL                                                : return "IKE authentication credentials are unacceptable";
    case ERROR_IPSEC_IKE_ATTRIB_FAIL                                              : return "IKE security attributes are unacceptable";
    case ERROR_IPSEC_IKE_NEGOTIATION_PENDING                                      : return "IKE Negotiation in progress";
    case ERROR_IPSEC_IKE_GENERAL_PROCESSING_ERROR                                 : return "General processing error";
    case ERROR_IPSEC_IKE_TIMED_OUT                                                : return "Negotiation timed out";
    case ERROR_IPSEC_IKE_NO_CERT                                                  : return "IKE failed to find valid machine certificate. Contact your Network Security Administrator about installing a valid certificate in the appropriate Certificate Store";
    case ERROR_IPSEC_IKE_SA_DELETED                                               : return "IKE SA deleted by peer before establishment completed";
    case ERROR_IPSEC_IKE_SA_REAPED                                                : return "IKE SA deleted before establishment completed";
    case ERROR_IPSEC_IKE_MM_ACQUIRE_DROP                                          : return "Negotiation request sat in Queue too long";
    case ERROR_IPSEC_IKE_QM_ACQUIRE_DROP                                          : return "Negotiation request sat in Queue too long";
    case ERROR_IPSEC_IKE_QUEUE_DROP_MM                                            : return "Negotiation request sat in Queue too long";
    case ERROR_IPSEC_IKE_QUEUE_DROP_NO_MM                                         : return "Negotiation request sat in Queue too long";
    case ERROR_IPSEC_IKE_DROP_NO_RESPONSE                                         : return "No response from peer";
    case ERROR_IPSEC_IKE_MM_DELAY_DROP                                            : return "Negotiation took too long";
    case ERROR_IPSEC_IKE_QM_DELAY_DROP                                            : return "Negotiation took too long";
    case ERROR_IPSEC_IKE_ERROR                                                    : return "Unknown error occurred";
    case ERROR_IPSEC_IKE_CRL_FAILED                                               : return "Certificate Revocation Check failed";
    case ERROR_IPSEC_IKE_INVALID_KEY_USAGE                                        : return "Invalid certificate key usage";
    case ERROR_IPSEC_IKE_INVALID_CERT_TYPE                                        : return "Invalid certificate type";
    case ERROR_IPSEC_IKE_NO_PRIVATE_KEY                                           : return "IKE negotiation failed because the machine certificate used does not have a private key. IPsec certificates require a private key. Contact your Network Security administrator about replacing with a certificate that has a private key";
    case ERROR_IPSEC_IKE_SIMULTANEOUS_REKEY                                       : return "Simultaneous rekeys were detected";
    case ERROR_IPSEC_IKE_DH_FAIL                                                  : return "Failure in Diffie-Hellman computation";
    case ERROR_IPSEC_IKE_CRITICAL_PAYLOAD_NOT_RECOGNIZED                          : return "Don't know how to process critical payload";
    case ERROR_IPSEC_IKE_INVALID_HEADER                                           : return "Invalid header";
    case ERROR_IPSEC_IKE_NO_POLICY                                                : return "No policy configured";
    case ERROR_IPSEC_IKE_INVALID_SIGNATURE                                        : return "Failed to verify signature";
    case ERROR_IPSEC_IKE_KERBEROS_ERROR                                           : return "Failed to authenticate using Kerberos";
    case ERROR_IPSEC_IKE_NO_PUBLIC_KEY                                            : return "Peer's certificate did not have a public key";
    case ERROR_IPSEC_IKE_PROCESS_ERR                                              : return "Error processing error payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_SA                                           : return "Error processing SA payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_PROP                                         : return "Error processing Proposal payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_TRANS                                        : return "Error processing Transform payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_KE                                           : return "Error processing KE payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_ID                                           : return "Error processing ID payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_CERT                                         : return "Error processing Cert payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_CERT_REQ                                     : return "Error processing Certificate Request payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_HASH                                         : return "Error processing Hash payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_SIG                                          : return "Error processing Signature payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_NONCE                                        : return "Error processing Nonce payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_NOTIFY                                       : return "Error processing Notify payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_DELETE                                       : return "Error processing Delete Payload";
    case ERROR_IPSEC_IKE_PROCESS_ERR_VENDOR                                       : return "Error processing VendorId payload";
    case ERROR_IPSEC_IKE_INVALID_PAYLOAD                                          : return "Invalid payload received";
    case ERROR_IPSEC_IKE_LOAD_SOFT_SA                                             : return "Soft SA loaded";
    case ERROR_IPSEC_IKE_SOFT_SA_TORN_DOWN                                        : return "Soft SA torn down";
    case ERROR_IPSEC_IKE_INVALID_COOKIE                                           : return "Invalid cookie received";
    case ERROR_IPSEC_IKE_NO_PEER_CERT                                             : return "Peer failed to send valid machine certificate";
    case ERROR_IPSEC_IKE_PEER_CRL_FAILED                                          : return "Certification Revocation check of peer's certificate failed";
    case ERROR_IPSEC_IKE_POLICY_CHANGE                                            : return "New policy invalidated SAs formed with old policy";
    case ERROR_IPSEC_IKE_NO_MM_POLICY                                             : return "There is no available Main Mode IKE policy";
    case ERROR_IPSEC_IKE_NOTCBPRIV                                                : return "Failed to enabled TCB privilege";
    case ERROR_IPSEC_IKE_SECLOADFAIL                                              : return "Failed to load SECURITY.DLL";
    case ERROR_IPSEC_IKE_FAILSSPINIT                                              : return "Failed to obtain security function table dispatch address from SSPI";
    case ERROR_IPSEC_IKE_FAILQUERYSSP                                             : return "Failed to query Kerberos package to obtain max token size";
    case ERROR_IPSEC_IKE_SRVACQFAIL                                               : return "Failed to obtain Kerberos server credentials for ISAKMP/ERROR_IPSEC_IKE service. Kerberos authentication will not function. The most likely reason for this is lack of domain membership. This is normal if your computer is a member of a workgroup";
    case ERROR_IPSEC_IKE_SRVQUERYCRED                                             : return "Failed to determine SSPI principal name for ISAKMP/ERROR_IPSEC_IKE service (QueryCredentialsAttributes)";
    case ERROR_IPSEC_IKE_GETSPIFAIL                                               : return "Failed to obtain new SPI for the inbound SA from IPsec driver. The most common cause for this is that the driver does not have the correct filter. Check your policy to verify the filters";
    case ERROR_IPSEC_IKE_INVALID_FILTER                                           : return "Given filter is invalid";
    case ERROR_IPSEC_IKE_OUT_OF_MEMORY                                            : return "Memory allocation failed";
    case ERROR_IPSEC_IKE_ADD_UPDATE_KEY_FAILED                                    : return "Failed to add Security Association to IPsec Driver. The most common cause for this is if the IKE negotiation took too long to complete. If the problem persists, reduce the load on the faulting machine";
    case ERROR_IPSEC_IKE_INVALID_POLICY                                           : return "Invalid policy";
    case ERROR_IPSEC_IKE_UNKNOWN_DOI                                              : return "Invalid DOI";
    case ERROR_IPSEC_IKE_INVALID_SITUATION                                        : return "Invalid situation";
    case ERROR_IPSEC_IKE_DH_FAILURE                                               : return "Diffie-Hellman failure";
    case ERROR_IPSEC_IKE_INVALID_GROUP                                            : return "Invalid Diffie-Hellman group";
    case ERROR_IPSEC_IKE_ENCRYPT                                                  : return "Error encrypting payload";
    case ERROR_IPSEC_IKE_DECRYPT                                                  : return "Error decrypting payload";
    case ERROR_IPSEC_IKE_POLICY_MATCH                                             : return "Policy match error";
    case ERROR_IPSEC_IKE_UNSUPPORTED_ID                                           : return "Unsupported ID";
    case ERROR_IPSEC_IKE_INVALID_HASH                                             : return "Hash verification failed";
    case ERROR_IPSEC_IKE_INVALID_HASH_ALG                                         : return "Invalid hash algorithm";
    case ERROR_IPSEC_IKE_INVALID_HASH_SIZE                                        : return "Invalid hash size";
    case ERROR_IPSEC_IKE_INVALID_ENCRYPT_ALG                                      : return "Invalid encryption algorithm";
    case ERROR_IPSEC_IKE_INVALID_AUTH_ALG                                         : return "Invalid authentication algorithm";
    case ERROR_IPSEC_IKE_INVALID_SIG                                              : return "Invalid certificate signature";
    case ERROR_IPSEC_IKE_LOAD_FAILED                                              : return "Load failed";
    case ERROR_IPSEC_IKE_RPC_DELETE                                               : return "Deleted via RPC call";
    case ERROR_IPSEC_IKE_BENIGN_REINIT                                            : return "Temporary state created to perform reinitialization. This is not a real failure";
    case ERROR_IPSEC_IKE_INVALID_RESPONDER_LIFETIME_NOTIFY                        : return "The lifetime value received in the Responder Lifetime Notify is below the Windows 2000 configured minimum value. Please fix the policy on the peer machine";
    case ERROR_IPSEC_IKE_INVALID_MAJOR_VERSION                                    : return "The recipient cannot handle version of IKE specified in the header";
    case ERROR_IPSEC_IKE_INVALID_CERT_KEYLEN                                      : return "Key length in certificate is too small for configured security requirements";
    case ERROR_IPSEC_IKE_MM_LIMIT                                                 : return "Max number of established MM SAs to peer exceeded";
    case ERROR_IPSEC_IKE_NEGOTIATION_DISABLED                                     : return "IKE received a policy that disables negotiation";
    case ERROR_IPSEC_IKE_QM_LIMIT                                                 : return "Reached maximum quick mode limit for the main mode. New main mode will be started";
    case ERROR_IPSEC_IKE_MM_EXPIRED                                               : return "Main mode SA lifetime expired or peer sent a main mode delete";
    case ERROR_IPSEC_IKE_PEER_MM_ASSUMED_INVALID                                  : return "Main mode SA assumed to be invalid because peer stopped responding";
    case ERROR_IPSEC_IKE_CERT_CHAIN_POLICY_MISMATCH                               : return "Certificate doesn't chain to a trusted root in IPsec policy";
    case ERROR_IPSEC_IKE_UNEXPECTED_MESSAGE_ID                                    : return "Received unexpected message ID";
    case ERROR_IPSEC_IKE_INVALID_AUTH_PAYLOAD                                     : return "Received invalid authentication offers";
    case ERROR_IPSEC_IKE_DOS_COOKIE_SENT                                          : return "Sent DoS cookie notify to initiator";
    case ERROR_IPSEC_IKE_SHUTTING_DOWN                                            : return "IKE service is shutting down";
    case ERROR_IPSEC_IKE_CGA_AUTH_FAILED                                          : return "Could not verify binding between CGA address and certificate";
    case ERROR_IPSEC_IKE_PROCESS_ERR_NATOA                                        : return "Error processing NatOA payload";
    case ERROR_IPSEC_IKE_INVALID_MM_FOR_QM                                        : return "Parameters of the main mode are invalid for this quick mode";
    case ERROR_IPSEC_IKE_QM_EXPIRED                                               : return "Quick mode SA was expired by IPsec driver";
    case ERROR_IPSEC_IKE_TOO_MANY_FILTERS                                         : return "Too many dynamically added IKEEXT filters were detected";
    case ERROR_IPSEC_IKE_NEG_STATUS_END                                           : return "ERROR_IPSEC_IKE_NEG_STATUS_END";
    case ERROR_IPSEC_IKE_KILL_DUMMY_NAP_TUNNEL                                    : return "NAP reauth succeeded and must delete the dummy NAP IKEv2 tunnel";
    case ERROR_IPSEC_IKE_INNER_IP_ASSIGNMENT_FAILURE                              : return "Error in assigning inner IP address to initiator in tunnel mode";
    case ERROR_IPSEC_IKE_REQUIRE_CP_PAYLOAD_MISSING                               : return "Require configuration payload missing";
    case ERROR_IPSEC_KEY_MODULE_IMPERSONATION_NEGOTIATION_PENDING                 : return "A negotiation running as the security principle who issued the connection is in progress";
    case ERROR_IPSEC_IKE_COEXISTENCE_SUPPRESS                                     : return "SA was deleted due to IKEv1/AuthIP co-existence suppress check";
    case ERROR_IPSEC_IKE_RATELIMIT_DROP                                           : return "Incoming SA request was dropped due to peer IP address rate limiting";
    case ERROR_IPSEC_IKE_PEER_DOESNT_SUPPORT_MOBIKE                               : return "Peer does not support MOBIKE";
    case ERROR_IPSEC_IKE_AUTHORIZATION_FAILURE                                    : return "SA establishment is not authorized";
    case ERROR_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_FAILURE                        : return "SA establishment is not authorized because there is not a sufficiently strong PKINIT-based credential";
    case ERROR_IPSEC_IKE_AUTHORIZATION_FAILURE_WITH_OPTIONAL_RETRY                : return "SA establishment is not authorized.  You may need to enter updated or different credentials such as a smartcard";
    case ERROR_IPSEC_IKE_STRONG_CRED_AUTHORIZATION_AND_CERTMAP_FAILURE            : return "SA establishment is not authorized because there is not a sufficiently strong PKINIT-based credential. This might be related to certificate-to-account mapping failure for the SA";
    case ERROR_IPSEC_IKE_NEG_STATUS_EXTENDED_END                                  : return "ERROR_IPSEC_IKE_NEG_STATUS_EXTENDED_END";
    case ERROR_IPSEC_BAD_SPI                                                      : return "The SPI in the packet does not match a valid IPsec SA";
    case ERROR_IPSEC_SA_LIFETIME_EXPIRED                                          : return "Packet was received on an IPsec SA whose lifetime has expired";
    case ERROR_IPSEC_WRONG_SA                                                     : return "Packet was received on an IPsec SA that does not match the packet characteristics";
    case ERROR_IPSEC_REPLAY_CHECK_FAILED                                          : return "Packet sequence number replay check failed";
    case ERROR_IPSEC_INVALID_PACKET                                               : return "IPsec header and/or trailer in the packet is invalid";
    case ERROR_IPSEC_INTEGRITY_CHECK_FAILED                                       : return "IPsec integrity check failed";
    case ERROR_IPSEC_CLEAR_TEXT_DROP                                              : return "IPsec dropped a clear text packet";
    case ERROR_IPSEC_AUTH_FIREWALL_DROP                                           : return "IPsec dropped an incoming ESP packet in authenticated firewall mode. This drop is benign";
    case ERROR_IPSEC_THROTTLE_DROP                                                : return "IPsec dropped a packet due to DoS throttling";
    case ERROR_IPSEC_DOSP_BLOCK                                                   : return "IPsec DoS Protection matched an explicit block rule";
    case ERROR_IPSEC_DOSP_RECEIVED_MULTICAST                                      : return "IPsec DoS Protection received an IPsec specific multicast packet which is not allowed";
    case ERROR_IPSEC_DOSP_INVALID_PACKET                                          : return "IPsec DoS Protection received an incorrectly formatted packet";
    case ERROR_IPSEC_DOSP_STATE_LOOKUP_FAILED                                     : return "IPsec DoS Protection failed to look up state";
    case ERROR_IPSEC_DOSP_MAX_ENTRIES                                             : return "IPsec DoS Protection failed to create state because the maximum number of entries allowed by policy has been reached";
    case ERROR_IPSEC_DOSP_KEYMOD_NOT_ALLOWED                                      : return "IPsec DoS Protection received an IPsec negotiation packet for a keying module which is not allowed by policy";
    case ERROR_IPSEC_DOSP_NOT_INSTALLED                                           : return "IPsec DoS Protection has not been enabled";
    case ERROR_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES                             : return "IPsec DoS Protection failed to create a per internal IP rate limit queue because the maximum number of queues allowed by policy has been reached";
    case ERROR_SXS_SECTION_NOT_FOUND                                              : return "The requested section was not present in the activation context";
    case ERROR_SXS_CANT_GEN_ACTCTX                                                : return "The application has failed to start because its side-by-side configuration is incorrect. Please see the application event log or use the command-line sxstrace.exe tool for more detail";
    case ERROR_SXS_INVALID_ACTCTXDATA_FORMAT                                      : return "The application binding data format is invalid";
    case ERROR_SXS_ASSEMBLY_NOT_FOUND                                             : return "The referenced assembly is not installed on your system";
    case ERROR_SXS_MANIFEST_FORMAT_ERROR                                          : return "The manifest file does not begin with the required tag and format information";
    case ERROR_SXS_MANIFEST_PARSE_ERROR                                           : return "The manifest file contains one or more syntax errors";
    case ERROR_SXS_ACTIVATION_CONTEXT_DISABLED                                    : return "The application attempted to activate a disabled activation context";
    case ERROR_SXS_KEY_NOT_FOUND                                                  : return "The requested lookup key was not found in any active activation context";
    case ERROR_SXS_VERSION_CONFLICT                                               : return "A component version required by the application conflicts with another component version already active";
    case ERROR_SXS_WRONG_SECTION_TYPE                                             : return "The type requested activation context section does not match the query API used";
    case ERROR_SXS_THREAD_QUERIES_DISABLED                                        : return "Lack of system resources has required isolated activation to be disabled for the current thread of execution";
    case ERROR_SXS_PROCESS_DEFAULT_ALREADY_SET                                    : return "An attempt to set the process default activation context failed because the process default activation context was already set";
    case ERROR_SXS_UNKNOWN_ENCODING_GROUP                                         : return "The encoding group identifier specified is not recognized";
    case ERROR_SXS_UNKNOWN_ENCODING                                               : return "The encoding requested is not recognized";
    case ERROR_SXS_INVALID_XML_NAMESPACE_URI                                      : return "The manifest contains a reference to an invalid URI";
    case ERROR_SXS_ROOT_MANIFEST_DEPENDENCY_NOT_INSTALLED                         : return "The application manifest contains a reference to a dependent assembly which is not installed";
    case ERROR_SXS_LEAF_MANIFEST_DEPENDENCY_NOT_INSTALLED                         : return "The manifest for an assembly used by the application has a reference to a dependent assembly which is not installed";
    case ERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE                            : return "The manifest contains an attribute for the assembly identity which is not valid";
    case ERROR_SXS_MANIFEST_MISSING_REQUIRED_DEFAULT_NAMESPACE                    : return "The manifest is missing the required default namespace specification on the assembly element";
    case ERROR_SXS_MANIFEST_INVALID_REQUIRED_DEFAULT_NAMESPACE                    : return "The manifest has a default namespace specified on the assembly element but its value is not \"urn:schemas-microsoft-com:asm.v1\"";
    case ERROR_SXS_PRIVATE_MANIFEST_CROSS_PATH_WITH_REPARSE_POINT                 : return "The private manifest probed has crossed a path with an unsupported reparse point";
    case ERROR_SXS_DUPLICATE_DLL_NAME                                             : return "Two or more components referenced directly or indirectly by the application manifest have files by the same name";
    case ERROR_SXS_DUPLICATE_WINDOWCLASS_NAME                                     : return "Two or more components referenced directly or indirectly by the application manifest have window classes with the same name";
    case ERROR_SXS_DUPLICATE_CLSID                                                : return "Two or more components referenced directly or indirectly by the application manifest have the same COM server CLSIDs";
    case ERROR_SXS_DUPLICATE_IID                                                  : return "Two or more components referenced directly or indirectly by the application manifest have proxies for the same COM interface IIDs";
    case ERROR_SXS_DUPLICATE_TLBID                                                : return "Two or more components referenced directly or indirectly by the application manifest have the same COM type library TLBIDs";
    case ERROR_SXS_DUPLICATE_PROGID                                               : return "Two or more components referenced directly or indirectly by the application manifest have the same COM ProgIDs";
    case ERROR_SXS_DUPLICATE_ASSEMBLY_NAME                                        : return "Two or more components referenced directly or indirectly by the application manifest are different versions of the same component which is not permitted";
    case ERROR_SXS_FILE_HASH_MISMATCH                                             : return "A component's file does not match the verification information present in the component manifest";
    case ERROR_SXS_POLICY_PARSE_ERROR                                             : return "The policy manifest contains one or more syntax errors";
    case ERROR_SXS_XML_E_MISSINGQUOTE                                             : return "Manifest Parse Error : A string literal was expected, but no opening quote character was found";
    case ERROR_SXS_XML_E_COMMENTSYNTAX                                            : return "Manifest Parse Error : Incorrect syntax was used in a comment";
    case ERROR_SXS_XML_E_BADSTARTNAMECHAR                                         : return "Manifest Parse Error : A name was started with an invalid character";
    case ERROR_SXS_XML_E_BADNAMECHAR                                              : return "Manifest Parse Error : A name contained an invalid character";
    case ERROR_SXS_XML_E_BADCHARINSTRING                                          : return "Manifest Parse Error : A string literal contained an invalid character";
    case ERROR_SXS_XML_E_XMLDECLSYNTAX                                            : return "Manifest Parse Error : Invalid syntax for an xml declaration";
    case ERROR_SXS_XML_E_BADCHARDATA                                              : return "Manifest Parse Error : An Invalid character was found in text content";
    case ERROR_SXS_XML_E_MISSINGWHITESPACE                                        : return "Manifest Parse Error : Required white space was missing";
    case ERROR_SXS_XML_E_EXPECTINGTAGEND                                          : return "Manifest Parse Error : The character '>' was expected";
    case ERROR_SXS_XML_E_MISSINGSEMICOLON                                         : return "Manifest Parse Error : A semi colon character was expected";
    case ERROR_SXS_XML_E_UNBALANCEDPAREN                                          : return "Manifest Parse Error : Unbalanced parentheses";
    case ERROR_SXS_XML_E_INTERNALERROR                                            : return "Manifest Parse Error : Internal error";
    case ERROR_SXS_XML_E_UNEXPECTED_WHITESPACE                                    : return "Manifest Parse Error : Whitespace is not allowed at this location";
    case ERROR_SXS_XML_E_INCOMPLETE_ENCODING                                      : return "Manifest Parse Error : End of file reached in invalid state for current encoding";
    case ERROR_SXS_XML_E_MISSING_PAREN                                            : return "Manifest Parse Error : Missing parenthesis";
    case ERROR_SXS_XML_E_EXPECTINGCLOSEQUOTE                                      : return "Manifest Parse Error : A single or double closing quote character (\\' or \\\") is missing";
    case ERROR_SXS_XML_E_MULTIPLE_COLONS                                          : return "Manifest Parse Error : Multiple colons are not allowed in a name";
    case ERROR_SXS_XML_E_INVALID_DECIMAL                                          : return "Manifest Parse Error : Invalid character for decimal digit";
    case ERROR_SXS_XML_E_INVALID_HEXIDECIMAL                                      : return "Manifest Parse Error : Invalid character for hexadecimal digit";
    case ERROR_SXS_XML_E_INVALID_UNICODE                                          : return "Manifest Parse Error : Invalid unicode character value for this platform";
    case ERROR_SXS_XML_E_WHITESPACEORQUESTIONMARK                                 : return "Manifest Parse Error : Expecting whitespace or '?'";
    case ERROR_SXS_XML_E_UNEXPECTEDENDTAG                                         : return "Manifest Parse Error : End tag was not expected at this location";
    case ERROR_SXS_XML_E_UNCLOSEDTAG                                              : return "Manifest Parse Error : The following tags were not closed: %%1";
    case ERROR_SXS_XML_E_DUPLICATEATTRIBUTE                                       : return "Manifest Parse Error : Duplicate attribute";
    case ERROR_SXS_XML_E_MULTIPLEROOTS                                            : return "Manifest Parse Error : Only one top level element is allowed in an XML document";
    case ERROR_SXS_XML_E_INVALIDATROOTLEVEL                                       : return "Manifest Parse Error : Invalid at the top level of the document";
    case ERROR_SXS_XML_E_BADXMLDECL                                               : return "Manifest Parse Error : Invalid xml declaration";
    case ERROR_SXS_XML_E_MISSINGROOT                                              : return "Manifest Parse Error : XML document must have a top level element";
    case ERROR_SXS_XML_E_UNEXPECTEDEOF                                            : return "Manifest Parse Error : Unexpected end of file";
    case ERROR_SXS_XML_E_BADPEREFINSUBSET                                         : return "Manifest Parse Error : Parameter entities cannot be used inside markup declarations in an internal subset";
    case ERROR_SXS_XML_E_UNCLOSEDSTARTTAG                                         : return "Manifest Parse Error : Element was not closed";
    case ERROR_SXS_XML_E_UNCLOSEDENDTAG                                           : return "Manifest Parse Error : End element was missing the character '>'";
    case ERROR_SXS_XML_E_UNCLOSEDSTRING                                           : return "Manifest Parse Error : A string literal was not closed";
    case ERROR_SXS_XML_E_UNCLOSEDCOMMENT                                          : return "Manifest Parse Error : A comment was not closed";
    case ERROR_SXS_XML_E_UNCLOSEDDECL                                             : return "Manifest Parse Error : A declaration was not closed";
    case ERROR_SXS_XML_E_UNCLOSEDCDATA                                            : return "Manifest Parse Error : A CDATA section was not closed";
    case ERROR_SXS_XML_E_RESERVEDNAMESPACE                                        : return "Manifest Parse Error : The namespace prefix is not allowed to start with the reserved string \"xml\"";
    case ERROR_SXS_XML_E_INVALIDENCODING                                          : return "Manifest Parse Error : System does not support the specified encoding";
    case ERROR_SXS_XML_E_INVALIDSWITCH                                            : return "Manifest Parse Error : Switch from current encoding to specified encoding not supported";
    case ERROR_SXS_XML_E_BADXMLCASE                                               : return "Manifest Parse Error : The name 'xml' is reserved and must be lower case";
    case ERROR_SXS_XML_E_INVALID_STANDALONE                                       : return "Manifest Parse Error : The standalone attribute must have the value 'yes' or 'no'";
    case ERROR_SXS_XML_E_UNEXPECTED_STANDALONE                                    : return "Manifest Parse Error : The standalone attribute cannot be used in external entities";
    case ERROR_SXS_XML_E_INVALID_VERSION                                          : return "Manifest Parse Error : Invalid version number";
    case ERROR_SXS_XML_E_MISSINGEQUALS                                            : return "Manifest Parse Error : Missing equals sign between attribute and attribute value";
    case ERROR_SXS_PROTECTION_RECOVERY_FAILED                                     : return "Assembly Protection Error : Unable to recover the specified assembly";
    case ERROR_SXS_PROTECTION_PUBLIC_KEY_TOO_SHORT                                : return "Assembly Protection Error : The public key for an assembly was too short to be allowed";
    case ERROR_SXS_PROTECTION_CATALOG_NOT_VALID                                   : return "Assembly Protection Error : The catalog for an assembly is not valid, or does not match the assembly's manifest";
    case ERROR_SXS_UNTRANSLATABLE_HRESULT                                         : return "An HRESULT could not be translated to a corresponding Win32 error code";
    case ERROR_SXS_PROTECTION_CATALOG_FILE_MISSING                                : return "Assembly Protection Error : The catalog for an assembly is missing";
    case ERROR_SXS_MISSING_ASSEMBLY_IDENTITY_ATTRIBUTE                            : return "The supplied assembly identity is missing one or more attributes which must be present in this context";
    case ERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME                       : return "The supplied assembly identity has one or more attribute names that contain characters not permitted in XML names";
    case ERROR_SXS_ASSEMBLY_MISSING                                               : return "The referenced assembly could not be found";
    case ERROR_SXS_CORRUPT_ACTIVATION_STACK                                       : return "The activation context activation stack for the running thread of execution is corrupt";
    case ERROR_SXS_CORRUPTION                                                     : return "The application isolation metadata for this process or thread has become corrupt";
    case ERROR_SXS_EARLY_DEACTIVATION                                             : return "The activation context being deactivated is not the most recently activated one";
    case ERROR_SXS_INVALID_DEACTIVATION                                           : return "The activation context being deactivated is not active for the current thread of execution";
    case ERROR_SXS_MULTIPLE_DEACTIVATION                                          : return "The activation context being deactivated has already been deactivated";
    case ERROR_SXS_PROCESS_TERMINATION_REQUESTED                                  : return "A component used by the isolation facility has requested to terminate the process";
    case ERROR_SXS_RELEASE_ACTIVATION_CONTEXT                                     : return "A kernel mode component is releasing a reference on an activation context";
    case ERROR_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY                        : return "The activation context of system default assembly could not be generated";
    case ERROR_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE                               : return "The value of an attribute in an identity is not within the legal range";
    case ERROR_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME                                : return "The name of an attribute in an identity is not within the legal range";
    case ERROR_SXS_IDENTITY_DUPLICATE_ATTRIBUTE                                   : return "An identity contains two definitions for the same attribute";
    case ERROR_SXS_IDENTITY_PARSE_ERROR                                           : return "The identity string is malformed. This may be due to a trailing comma, more than two unnamed attributes, missing attribute name or missing attribute value";
    case ERROR_MALFORMED_SUBSTITUTION_STRING                                      : return "A string containing localized substitutable content was malformed. Either a dollar sign ($) was followed by something other than a left parenthesis or another dollar sign or an substitution's right parenthesis was not found";
    case ERROR_SXS_INCORRECT_PUBLIC_KEY_TOKEN                                     : return "The public key token does not correspond to the public key specified";
    case ERROR_UNMAPPED_SUBSTITUTION_STRING                                       : return "A substitution string had no mapping";
    case ERROR_SXS_ASSEMBLY_NOT_LOCKED                                            : return "The component must be locked before making the request";
    case ERROR_SXS_COMPONENT_STORE_CORRUPT                                        : return "The component store has been corrupted";
    case ERROR_ADVANCED_INSTALLER_FAILED                                          : return "An advanced installer failed during setup or servicing";
    case ERROR_XML_ENCODING_MISMATCH                                              : return "The character encoding in the XML declaration did not match the encoding used in the document";
    case ERROR_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT                  : return "The identities of the manifests are identical but their contents are different";
    case ERROR_SXS_IDENTITIES_DIFFERENT                                           : return "The component identities are different";
    case ERROR_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT                                   : return "The assembly is not a deployment";
    case ERROR_SXS_FILE_NOT_PART_OF_ASSEMBLY                                      : return "The file is not a part of the assembly";
    case ERROR_SXS_MANIFEST_TOO_BIG                                               : return "The size of the manifest exceeds the maximum allowed";
    case ERROR_SXS_SETTING_NOT_REGISTERED                                         : return "The setting is not registered";
    case ERROR_SXS_TRANSACTION_CLOSURE_INCOMPLETE                                 : return "One or more required members of the transaction are not present";
    case ERROR_SMI_PRIMITIVE_INSTALLER_FAILED                                     : return "The SMI primitive installer failed during setup or servicing";
    case ERROR_GENERIC_COMMAND_FAILED                                             : return "A generic command executable returned a result that indicates failure";
    case ERROR_SXS_FILE_HASH_MISSING                                              : return "A component is missing file verification information in its manifest";
    case ERROR_EVT_INVALID_CHANNEL_PATH                                           : return "The specified channel path is invalid";
    case ERROR_EVT_INVALID_QUERY                                                  : return "The specified query is invalid";
    case ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND                                   : return "The publisher metadata cannot be found in the resource";
    case ERROR_EVT_EVENT_TEMPLATE_NOT_FOUND                                       : return "The template for an event definition cannot be found in the resource (error = %%1)";
    case ERROR_EVT_INVALID_PUBLISHER_NAME                                         : return "The specified publisher name is invalid";
    case ERROR_EVT_INVALID_EVENT_DATA                                             : return "The event data raised by the publisher is not compatible with the event template definition in the publisher's manifest";
    case ERROR_EVT_CHANNEL_NOT_FOUND                                              : return "The specified channel could not be found. Check channel configuration";
    case ERROR_EVT_MALFORMED_XML_TEXT                                             : return "The specified xml text was not well-formed. See Extended Error for more details";
    case ERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL                                 : return "The caller is trying to subscribe to a direct channel which is not allowed. The event for a direct channel go directly to a logfile and cannot be subscribed to";
    case ERROR_EVT_CONFIGURATION_ERROR                                            : return "Configuration error";
    case ERROR_EVT_QUERY_RESULT_STALE                                             : return "The query result is stale / invalid. This may be due to the log being cleared or rolling over after the query result was created. Users should handle this code by releasing the query result object and reissuing the query";
    case ERROR_EVT_QUERY_RESULT_INVALID_POSITION                                  : return "Query result is currently at an invalid position";
    case ERROR_EVT_NON_VALIDATING_MSXML                                           : return "Registered MSXML doesn't support validation";
    case ERROR_EVT_FILTER_ALREADYSCOPED                                           : return "An expression can only be followed by a change of scope operation if it itself evaluates to a node set and is not already part of some other change of scope operation";
    case ERROR_EVT_FILTER_NOTELTSET                                               : return "Can't perform a step operation from a term that does not represent an element set";
    case ERROR_EVT_FILTER_INVARG                                                  : return "Left hand side arguments to binary operators must be either attributes, nodes or variables and right hand side arguments must be constants";
    case ERROR_EVT_FILTER_INVTEST                                                 : return "A step operation must involve either a node test or, in the case of a predicate, an algebraic expression against which to test each node in the node set identified by the preceeding node set can be evaluated";
    case ERROR_EVT_FILTER_INVTYPE                                                 : return "This data type is currently unsupported";
    case ERROR_EVT_FILTER_PARSEERR                                                : return "A syntax error occurred at position %%1!d!";
    case ERROR_EVT_FILTER_UNSUPPORTEDOP                                           : return "This operator is unsupported by this implementation of the filter";
    case ERROR_EVT_FILTER_UNEXPECTEDTOKEN                                         : return "The token encountered was unexpected";
    case ERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL                  : return "The requested operation cannot be performed over an enabled direct channel. The channel must first be disabled before performing the requested operation";
    case ERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUE                                 : return "Channel property %%1!s! contains invalid value. The value has invalid type, is outside of valid range, can't be updated or is not supported by this type of channel";
    case ERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE                               : return "Publisher property %%1!s! contains invalid value. The value has invalid type, is outside of valid range, can't be updated or is not supported by this type of publisher";
    case ERROR_EVT_CHANNEL_CANNOT_ACTIVATE                                        : return "The channel fails to activate";
    case ERROR_EVT_FILTER_TOO_COMPLEX                                             : return "The xpath expression exceeded supported complexity. Please symplify it or split it into two or more simple expressions";
    case ERROR_EVT_MESSAGE_NOT_FOUND                                              : return "the message resource is present but the message is not found in the string/message table";
    case ERROR_EVT_MESSAGE_ID_NOT_FOUND                                           : return "The message id for the desired message could not be found";
    case ERROR_EVT_UNRESOLVED_VALUE_INSERT                                        : return "The substitution string for insert index (%%1) could not be found";
    case ERROR_EVT_UNRESOLVED_PARAMETER_INSERT                                    : return "The description string for parameter reference (%%1) could not be found";
    case ERROR_EVT_MAX_INSERTS_REACHED                                            : return "The maximum number of replacements has been reached";
    case ERROR_EVT_EVENT_DEFINITION_NOT_FOUND                                     : return "The event definition could not be found for event id (%%1)";
    case ERROR_EVT_MESSAGE_LOCALE_NOT_FOUND                                       : return "The locale specific resource for the desired message is not present";
    case ERROR_EVT_VERSION_TOO_OLD                                                : return "The resource is too old to be compatible";
    case ERROR_EVT_VERSION_TOO_NEW                                                : return "The resource is too new to be compatible";
    case ERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY                                   : return "The channel at index %%1!d! of the query can't be opened";
    case ERROR_EVT_PUBLISHER_DISABLED                                             : return "The publisher has been disabled and its resource is not available. This usually occurs when the publisher is in the process of being uninstalled or upgraded";
    case ERROR_EVT_FILTER_OUT_OF_RANGE                                            : return "Attempted to create a numeric type that is outside of its valid range";
    case ERROR_EC_SUBSCRIPTION_CANNOT_ACTIVATE                                    : return "The subscription fails to activate";
    case ERROR_EC_LOG_DISABLED                                                    : return "The log of the subscription is in disabled state, and can not be used to forward event to. The log must first be enabled before the subscription can be activated";
    case ERROR_EC_CIRCULAR_FORWARDING                                             : return "When forwarding event from local machine to itself, the query of the subscription can't contain target log of the subscription";
    case ERROR_EC_CREDSTORE_FULL                                                  : return "The credential store that is used to save credentials is full";
    case ERROR_EC_CRED_NOT_FOUND                                                  : return "The credential used by this subscription can't be found in credential store";
    case ERROR_EC_NO_ACTIVE_CHANNEL                                               : return "No active channel is found for the query";
    case ERROR_MUI_FILE_NOT_FOUND                                                 : return "The resource loader failed to find MUI file";
    case ERROR_MUI_INVALID_FILE                                                   : return "The resource loader failed to load MUI file because the file fail to pass validation";
    case ERROR_MUI_INVALID_RC_CONFIG                                              : return "The RC Manifest is corrupted with garbage data or unsupported version or missing required item";
    case ERROR_MUI_INVALID_LOCALE_NAME                                            : return "The RC Manifest has invalid culture name";
    case ERROR_MUI_INVALID_ULTIMATEFALLBACK_NAME                                  : return "The RC Manifest has invalid ultimatefallback name";
    case ERROR_MUI_FILE_NOT_LOADED                                                : return "The resource loader cache doesn't have loaded MUI entry";
    case ERROR_RESOURCE_ENUM_USER_STOP                                            : return "User stopped resource enumeration";
    case ERROR_MUI_INTLSETTINGS_UILANG_NOT_INSTALLED                              : return "UI language installation failed";
    case ERROR_MUI_INTLSETTINGS_INVALID_LOCALE_NAME                               : return "Locale installation failed";
    case ERROR_MRM_RUNTIME_NO_DEFAULT_OR_NEUTRAL_RESOURCE                         : return "A resource does not have default or neutral value";
    case ERROR_MRM_INVALID_PRICONFIG                                              : return "Invalid PRI config file";
    case ERROR_MRM_INVALID_FILE_TYPE                                              : return "Invalid file type";
    case ERROR_MRM_UNKNOWN_QUALIFIER                                              : return "Unknown qualifier";
    case ERROR_MRM_INVALID_QUALIFIER_VALUE                                        : return "Invalid qualifier value";
    case ERROR_MRM_NO_CANDIDATE                                                   : return "No Candidate found";
    case ERROR_MRM_NO_MATCH_OR_DEFAULT_CANDIDATE                                  : return "The ResourceMap or NamedResource has an item that does not have default or neutral resource.";
    case ERROR_MRM_RESOURCE_TYPE_MISMATCH                                         : return "Invalid ResourceCandidate type";
    case ERROR_MRM_DUPLICATE_MAP_NAME                                             : return "Duplicate Resource Map";
    case ERROR_MRM_DUPLICATE_ENTRY                                                : return "Duplicate Entry";
    case ERROR_MRM_INVALID_RESOURCE_IDENTIFIER                                    : return "Invalid Resource Identifier";
    case ERROR_MRM_FILEPATH_TOO_LONG                                              : return "Filepath too long";
    case ERROR_MRM_UNSUPPORTED_DIRECTORY_TYPE                                     : return "Unsupported directory type";
    case ERROR_MRM_INVALID_PRI_FILE                                               : return "Invalid PRI File";
    case ERROR_MRM_NAMED_RESOURCE_NOT_FOUND                                       : return "NamedResource Not Found";
    case ERROR_MRM_MAP_NOT_FOUND                                                  : return "ResourceMap Not Found";
    case ERROR_MRM_UNSUPPORTED_PROFILE_TYPE                                       : return "Unsupported MRT profile type";
    case ERROR_MRM_INVALID_QUALIFIER_OPERATOR                                     : return "Invalid qualifier operator";
    case ERROR_MRM_INDETERMINATE_QUALIFIER_VALUE                                  : return "Unable to determine qualifier value or qualifier value has not been set";
    case ERROR_MRM_AUTOMERGE_ENABLED                                              : return "Automerge is enabled in the PRI file";
    case ERROR_MRM_TOO_MANY_RESOURCES                                             : return "Too many resources defined for package";
    case ERROR_MRM_UNSUPPORTED_FILE_TYPE_FOR_MERGE                                : return "Resource File can not be used for merge operation";
    case ERROR_MRM_UNSUPPORTED_FILE_TYPE_FOR_LOAD_UNLOAD_PRI_FILE                 : return "Load/UnloadPriFiles cannot be used with resource packages";
    case ERROR_MRM_NO_CURRENT_VIEW_ON_THREAD                                      : return "Resource Contexts may not be created on threads that do not have a CoreWindow";
    case ERROR_DIFFERENT_PROFILE_RESOURCE_MANAGER_EXIST                           : return "The singleton Resource Manager with different profile is already created";
    case ERROR_OPERATION_NOT_ALLOWED_FROM_SYSTEM_COMPONENT                        : return "The system component cannot operate given API operation";
    case ERROR_MRM_DIRECT_REF_TO_NON_DEFAULT_RESOURCE                             : return "The resource is a direct reference to a non-default resource candidate";
    case ERROR_MRM_GENERATION_COUNT_MISMATCH                                      : return "Resource Map has been re-generated and the query string is not valid anymore";
    case ERROR_PRI_MERGE_VERSION_MISMATCH                                         : return "The PRI files to be merged have incompatible versions";
    case ERROR_PRI_MERGE_MISSING_SCHEMA                                           : return "The primary PRI files to be merged does not contain a schema";
    case ERROR_PRI_MERGE_LOAD_FILE_FAILED                                         : return "Unable to load one of the PRI files to be merged";
    case ERROR_PRI_MERGE_ADD_FILE_FAILED                                          : return "Unable to add one of the PRI files to the merged file";
    case ERROR_PRI_MERGE_WRITE_FILE_FAILED                                        : return "Unable to create the merged PRI file";
    case ERROR_PRI_MERGE_MULTIPLE_PACKAGE_FAMILIES_NOT_ALLOWED                    : return "Packages for a PRI file merge must all be from the same package family";
    case ERROR_PRI_MERGE_MULTIPLE_MAIN_PACKAGES_NOT_ALLOWED                       : return "Packages for a PRI file merge must not include multiple main packages";
    case ERROR_PRI_MERGE_BUNDLE_PACKAGES_NOT_ALLOWED                              : return "Packages for a PRI file merge must not include bundle packages";
    case ERROR_PRI_MERGE_MAIN_PACKAGE_REQUIRED                                    : return "Packages for a PRI file merge must include one main package";
    case ERROR_PRI_MERGE_RESOURCE_PACKAGE_REQUIRED                                : return "Packages for a PRI file merge must include at least one resource package";
    case ERROR_PRI_MERGE_INVALID_FILE_NAME                                        : return "Invalid name supplied for a canonical merged PRI file";
    case ERROR_MCA_INVALID_CAPABILITIES_STRING                                    : return "The monitor returned a DDC/CI capabilities string that did not comply with the ACCESS.bus 3.0, DDC/CI 1.1 or MCCS 2 Revision 1 specification";
    case ERROR_MCA_INVALID_VCP_VERSION                                            : return "The monitor's VCP Version (0xDF) VCP code returned an invalid version value";
    case ERROR_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION                            : return "The monitor does not comply with the MCCS specification it claims to support";
    case ERROR_MCA_MCCS_VERSION_MISMATCH                                          : return "The MCCS version in a monitor's mccs_ver capability does not match the MCCS version the monitor reports when the VCP Version (0xDF) VCP code is used";
    case ERROR_MCA_UNSUPPORTED_MCCS_VERSION                                       : return "The Monitor Configuration API only works with monitors that support the MCCS 1.0 specification, MCCS 2.0 specification or the MCCS 2.0 Revision 1 specification";
    case ERROR_MCA_INTERNAL_ERROR                                                 : return "An internal Monitor Configuration API error occurred";
    case ERROR_MCA_INVALID_TECHNOLOGY_TYPE_RETURNED                               : return "The monitor returned an invalid monitor technology type. CRT, Plasma and LCD (TFT) are examples of monitor technology types. This error implies that the monitor violated the MCCS 2.0 or MCCS 2.0 Revision 1 specification";
    case ERROR_MCA_UNSUPPORTED_COLOR_TEMPERATURE                                  : return "The caller of SetMonitorColorTemperature specified a color temperature that the current monitor did not support. This error implies that the monitor violated the MCCS 2.0 or MCCS 2.0 Revision 1 specification";
    case ERROR_AMBIGUOUS_SYSTEM_DEVICE                                            : return "The requested system device cannot be identified due to multiple indistinguishable devices potentially matching the identification criteria";
    case ERROR_SYSTEM_DEVICE_NOT_FOUND                                            : return "The requested system device cannot be found";
    case ERROR_HASH_NOT_SUPPORTED                                                 : return "Hash generation for the specified hash version and hash type is not enabled on the server";
    case ERROR_HASH_NOT_PRESENT                                                   : return "The hash requested from the server is not available or no longer valid";
    case ERROR_SECONDARY_IC_PROVIDER_NOT_REGISTERED                               : return "The secondary interrupt controller instance that manages the specified interrupt is not registered";
    case ERROR_GPIO_CLIENT_INFORMATION_INVALID                                    : return "The information supplied by the GPIO client driver is invalid";
    case ERROR_GPIO_VERSION_NOT_SUPPORTED                                         : return "The version specified by the GPIO client driver is not supported";
    case ERROR_GPIO_INVALID_REGISTRATION_PACKET                                   : return "The registration packet supplied by the GPIO client driver is not valid";
    case ERROR_GPIO_OPERATION_DENIED                                              : return "The requested operation is not suppported for the specified handle";
    case ERROR_GPIO_INCOMPATIBLE_CONNECT_MODE                                     : return "The requested connect mode conflicts with an existing mode on one or more of the specified pins";
    case ERROR_GPIO_INTERRUPT_ALREADY_UNMASKED                                    : return "The interrupt requested to be unmasked is not masked";
    case ERROR_CANNOT_SWITCH_RUNLEVEL                                             : return "The requested run level switch cannot be completed successfully";
    case ERROR_INVALID_RUNLEVEL_SETTING                                           : return "The service has an invalid run level setting. The run level for a service";
    case ERROR_RUNLEVEL_SWITCH_TIMEOUT                                            : return "The requested run level switch cannot be completed successfully since";
    case ERROR_RUNLEVEL_SWITCH_AGENT_TIMEOUT                                      : return "A run level switch agent did not respond within the specified timeout";
    case ERROR_RUNLEVEL_SWITCH_IN_PROGRESS                                        : return "A run level switch is currently in progress";
    case ERROR_SERVICES_FAILED_AUTOSTART                                          : return "One or more services failed to start during the service startup phase of a run level switch";
    case ERROR_COM_TASK_STOP_PENDING                                              : return "The task stop request cannot be completed immediately since";
    case ERROR_INSTALL_OPEN_PACKAGE_FAILED                                        : return "Package could not be opened";
    case ERROR_INSTALL_PACKAGE_NOT_FOUND                                          : return "Package was not found";
    case ERROR_INSTALL_INVALID_PACKAGE                                            : return "Package data is invalid";
    case ERROR_INSTALL_RESOLVE_DEPENDENCY_FAILED                                  : return "Package failed updates, dependency or conflict validation";
    case ERROR_INSTALL_OUT_OF_DISK_SPACE                                          : return "There is not enough disk space on your computer. Please free up some space and try again";
    case ERROR_INSTALL_NETWORK_FAILURE                                            : return "There was a problem downloading your product";
    case ERROR_INSTALL_REGISTRATION_FAILURE                                       : return "Package could not be registered";
    case ERROR_INSTALL_DEREGISTRATION_FAILURE                                     : return "Package could not be unregistered";
    case ERROR_INSTALL_CANCEL                                                     : return "User cancelled the install request";
    case ERROR_INSTALL_FAILED                                                     : return "Install failed. Please contact your software vendor";
    case ERROR_REMOVE_FAILED                                                      : return "Removal failed. Please contact your software vendor";
    case ERROR_PACKAGE_ALREADY_EXISTS                                             : return "The provided package is already installed, and reinstallation of the package was blocked. Check the AppXDeployment-Server event log for details";
    case ERROR_NEEDS_REMEDIATION                                                  : return "The application cannot be started. Try reinstalling the application to fix the problem";
    case ERROR_INSTALL_PREREQUISITE_FAILED                                        : return "A Prerequisite for an install could not be satisfied";
    case ERROR_PACKAGE_REPOSITORY_CORRUPTED                                       : return "The package repository is corrupted";
    case ERROR_INSTALL_POLICY_FAILURE                                             : return "To install this application you need either a Windows developer license or a sideloading-enabled system";
    case ERROR_PACKAGE_UPDATING                                                   : return "The application cannot be started because it is currently updating";
    case ERROR_DEPLOYMENT_BLOCKED_BY_POLICY                                       : return "The package deployment operation is blocked by policy. Please contact your system administrator";
    case ERROR_PACKAGES_IN_USE                                                    : return "The package could not be installed because resources it modifies are currently in use";
    case ERROR_RECOVERY_FILE_CORRUPT                                              : return "The package could not be recovered because necessary data for recovery have been corrupted";
    case ERROR_INVALID_STAGED_SIGNATURE                                           : return "The signature is invalid. To register in developer mode, AppxSignature.p7x and AppxBlockMap.xml must be valid or should not be present";
    case ERROR_DELETING_EXISTING_APPLICATIONDATA_STORE_FAILED                     : return "An error occurred while deleting the package's previously existing application data";
    case ERROR_INSTALL_PACKAGE_DOWNGRADE                                          : return "The package could not be installed because a higher version of this package is already installed";
    case ERROR_SYSTEM_NEEDS_REMEDIATION                                           : return "An error in a system binary was detected. Try refreshing the PC to fix the problem";
    case ERROR_APPX_INTEGRITY_FAILURE_CLR_NGEN                                    : return "A corrupted CLR NGEN binary was detected on the system";
    case ERROR_RESILIENCY_FILE_CORRUPT                                            : return "The operation could not be resumed because necessary data for recovery have been corrupted";
    case ERROR_INSTALL_FIREWALL_SERVICE_NOT_RUNNING                               : return "The package could not be installed because the Windows Firewall service is not running. Enable the Windows Firewall service and try again";
    case ERROR_PACKAGE_MOVE_FAILED                                                : return "Package move failed";
    case ERROR_INSTALL_VOLUME_NOT_EMPTY                                           : return "The deployment operation failed because the volume is not empty";
    case ERROR_INSTALL_VOLUME_OFFLINE                                             : return "The deployment operation failed because the volume is offline";
    case ERROR_INSTALL_VOLUME_CORRUPT                                             : return "The deployment operation failed because the specified volume is corrupt";
    case ERROR_NEEDS_REGISTRATION                                                 : return "The deployment operation failed because the specified application needs to be registered first";
    case ERROR_INSTALL_WRONG_PROCESSOR_ARCHITECTURE                               : return "The deployment operation failed because the package targets the wrong processor architecture";
    case ERROR_DEV_SIDELOAD_LIMIT_EXCEEDED                                        : return "You have reached the maximum number of developer sideloaded packages allowed on this device. Please uninstall a sideloaded package and try again";
    case ERROR_INSTALL_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE                     : return "A main app package is required to install this optional package.  Install the main package first and try again";
    case ERROR_PACKAGE_NOT_SUPPORTED_ON_FILESYSTEM                                : return "This app package type is not supported on this filesystem";
    case ERROR_PACKAGE_MOVE_BLOCKED_BY_STREAMING                                  : return "Package move operation is blocked until the application has finished streaming";
    case ERROR_INSTALL_OPTIONAL_PACKAGE_APPLICATIONID_NOT_UNIQUE                  : return "A main or another optional app package has the same application ID as this optional package.  Change the application ID for the optional package to avoid conflicts";
    case ERROR_PACKAGE_STAGING_ONHOLD                                             : return "This staging session has been held to allow another staging operation to be prioritized";
    case ERROR_INSTALL_INVALID_RELATED_SET_UPDATE                                 : return "A related set cannot be updated because the updated set is invalid. All packages in the related set must be updated at the same time";
    case ERROR_INSTALL_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE_FULLTRUST_CAPABILITY: return "An optional package with a FullTrust entry point requires the main package to have the runFullTrust capability";
    case ERROR_DEPLOYMENT_BLOCKED_BY_USER_LOG_OFF                                 : return "An error occurred because a user was logged off";
    case ERROR_PROVISION_OPTIONAL_PACKAGE_REQUIRES_MAIN_PACKAGE_PROVISIONED       : return "An optional package provision requires the dependency main package to also be provisioned";
    case ERROR_PACKAGES_REPUTATION_CHECK_FAILED                                   : return "The packages failed the SmartScreen reputation check";
    case ERROR_PACKAGES_REPUTATION_CHECK_TIMEDOUT                                 : return "The SmartScreen reputation check operation timed out";
    case APPMODEL_ERROR_NO_PACKAGE                                                : return "The process has no package identity";
    case APPMODEL_ERROR_PACKAGE_RUNTIME_CORRUPT                                   : return "The package runtime information is corrupted";
    case APPMODEL_ERROR_PACKAGE_IDENTITY_CORRUPT                                  : return "The package identity is corrupted";
    case APPMODEL_ERROR_NO_APPLICATION                                            : return "The process has no application identity";
    case APPMODEL_ERROR_DYNAMIC_PROPERTY_READ_FAILED                              : return "One or more AppModel Runtime group policy values could not be read. Please contact your system administrator with the contents of your AppModel Runtime event log";
    case APPMODEL_ERROR_DYNAMIC_PROPERTY_INVALID                                  : return "One or more AppModel Runtime group policy values are invalid. Please contact your system administrator with the contents of your AppModel Runtime event log";
    case APPMODEL_ERROR_PACKAGE_NOT_AVAILABLE                                     : return "The package is currently not available";
    case ERROR_STATE_LOAD_STORE_FAILED                                            : return "Loading the state store failed";
    case ERROR_STATE_GET_VERSION_FAILED                                           : return "Retrieving the state version for the application failed";
    case ERROR_STATE_SET_VERSION_FAILED                                           : return "Setting the state version for the application failed";
    case ERROR_STATE_STRUCTURED_RESET_FAILED                                      : return "Resetting the structured state of the application failed";
    case ERROR_STATE_OPEN_CONTAINER_FAILED                                        : return "State Manager failed to open the container";
    case ERROR_STATE_CREATE_CONTAINER_FAILED                                      : return "State Manager failed to create the container";
    case ERROR_STATE_DELETE_CONTAINER_FAILED                                      : return "State Manager failed to delete the container";
    case ERROR_STATE_READ_SETTING_FAILED                                          : return "State Manager failed to read the setting";
    case ERROR_STATE_WRITE_SETTING_FAILED                                         : return "State Manager failed to write the setting";
    case ERROR_STATE_DELETE_SETTING_FAILED                                        : return "State Manager failed to delete the setting";
    case ERROR_STATE_QUERY_SETTING_FAILED                                         : return "State Manager failed to query the setting";
    case ERROR_STATE_READ_COMPOSITE_SETTING_FAILED                                : return "State Manager failed to read the composite setting";
    case ERROR_STATE_WRITE_COMPOSITE_SETTING_FAILED                               : return "State Manager failed to write the composite setting";
    case ERROR_STATE_ENUMERATE_CONTAINER_FAILED                                   : return "State Manager failed to enumerate the containers";
    case ERROR_STATE_ENUMERATE_SETTINGS_FAILED                                    : return "State Manager failed to enumerate the settings";
    case ERROR_STATE_COMPOSITE_SETTING_VALUE_SIZE_LIMIT_EXCEEDED                  : return "The size of the state manager composite setting value has exceeded the limit";
    case ERROR_STATE_SETTING_VALUE_SIZE_LIMIT_EXCEEDED                            : return "The size of the state manager setting value has exceeded the limit";
    case ERROR_STATE_SETTING_NAME_SIZE_LIMIT_EXCEEDED                             : return "The length of the state manager setting name has exceeded the limit";
    case ERROR_STATE_CONTAINER_NAME_SIZE_LIMIT_EXCEEDED                           : return "The length of the state manager container name has exceeded the limit";
    case ERROR_API_UNAVAILABLE                                                    : return "This API cannot be used in the context of the caller's application type";
    case STORE_ERROR_UNLICENSED                                                   : return "This PC does not have a valid license for the application or product";
    case STORE_ERROR_UNLICENSED_USER                                              : return "The authenticated user does not have a valid license for the application or product";
    case STORE_ERROR_PENDING_COM_TRANSACTION                                      : return "The commerce transaction associated with this license is still pending verification";
    case STORE_ERROR_LICENSE_REVOKED                                              : return "The license has been revoked for this user";
    case E_UNEXPECTED                                                             : return "Catastrophic failure";
    case E_NOTIMPL                                                                : return "Not implemented";
    case E_OUTOFMEMORY                                                            : return "Ran out of memory";
    case E_INVALIDARG                                                             : return "One or more arguments are invalid";
    case E_NOINTERFACE                                                            : return "No such interface supported";
    case E_POINTER                                                                : return "Invalid pointer";
    case E_HANDLE                                                                 : return "Invalid handle";
    case E_ABORT                                                                  : return "Operation aborted";
    case E_FAIL                                                                   : return "Unspecified error";
    case E_ACCESSDENIED                                                           : return "General access denied error";
    case E_PENDING                                                                : return "The data necessary to complete this operation is not yet available";
    case E_BOUNDS                                                                 : return "The operation attempted to access data outside the valid range";
    case E_CHANGED_STATE                                                          : return "A concurrent or interleaved operation changed the state of the object, invalidating this operation";
    case E_ILLEGAL_STATE_CHANGE                                                   : return "An illegal state change was requested";
    case E_ILLEGAL_METHOD_CALL                                                    : return "A method was called at an unexpected time";
    case RO_E_METADATA_NAME_NOT_FOUND                                             : return "Typename or Namespace was not found in metadata file";
    case RO_E_METADATA_NAME_IS_NAMESPACE                                          : return "Name is an existing namespace rather than a typename";
    case RO_E_METADATA_INVALID_TYPE_FORMAT                                        : return "Typename has an invalid format";
    case RO_E_INVALID_METADATA_FILE                                               : return "Metadata file is invalid or corrupted";
    case RO_E_CLOSED                                                              : return "The object has been closed";
    case RO_E_EXCLUSIVE_WRITE                                                     : return "Only one thread may access the object during a write operation";
    case RO_E_CHANGE_NOTIFICATION_IN_PROGRESS                                     : return "Operation is prohibited during change notification";
    case RO_E_ERROR_STRING_NOT_FOUND                                              : return "The text associated with this error code could not be found";
    case E_STRING_NOT_NULL_TERMINATED                                             : return "String not null terminated";
    case E_ILLEGAL_DELEGATE_ASSIGNMENT                                            : return "A delegate was assigned when not allowed";
    case E_ASYNC_OPERATION_NOT_STARTED                                            : return "An async operation was not properly started";
    case E_APPLICATION_EXITING                                                    : return "The application is exiting and cannot service this request";
    case E_APPLICATION_VIEW_EXITING                                               : return "The application view is exiting and cannot service this request";
    case RO_E_MUST_BE_AGILE                                                       : return "The object must support the IAgileObject interface";
    case RO_E_UNSUPPORTED_FROM_MTA                                                : return "Activating a single-threaded class from MTA is not supported";
    case RO_E_COMMITTED                                                           : return "The object has been committed";
    case RO_E_BLOCKED_CROSS_ASTA_CALL                                             : return "A COM call to an ASTA was blocked because the call chain originated in or passed through another ASTA. This call pattern is deadlock-prone and disallowed by apartment call control";
    case RO_E_CANNOT_ACTIVATE_FULL_TRUST_SERVER                                   : return "A universal application process cannot activate a packaged WinRT server that is declared to run full trust";
    case RO_E_CANNOT_ACTIVATE_UNIVERSAL_APPLICATION_SERVER                        : return "A full trust packaged application process cannot activate a packaged WinRT server unless it is also declared to run full trust";
    case CO_E_INIT_TLS                                                            : return "Thread local storage failure";
    case CO_E_INIT_SHARED_ALLOCATOR                                               : return "Get shared memory allocator failure";
    case CO_E_INIT_MEMORY_ALLOCATOR                                               : return "Get memory allocator failure";
    case CO_E_INIT_CLASS_CACHE                                                    : return "Unable to initialize class cache";
    case CO_E_INIT_RPC_CHANNEL                                                    : return "Unable to initialize RPC services";
    case CO_E_INIT_TLS_SET_CHANNEL_CONTROL                                        : return "Cannot set thread local storage channel control";
    case CO_E_INIT_TLS_CHANNEL_CONTROL                                            : return "Could not allocate thread local storage channel control";
    case CO_E_INIT_UNACCEPTED_USER_ALLOCATOR                                      : return "The user supplied memory allocator is unacceptable";
    case CO_E_INIT_SCM_MUTEX_EXISTS                                               : return "The OLE service mutex already exists";
    case CO_E_INIT_SCM_FILE_MAPPING_EXISTS                                        : return "The OLE service file mapping already exists";
    case CO_E_INIT_SCM_MAP_VIEW_OF_FILE                                           : return "Unable to map view of file for OLE service";
    case CO_E_INIT_SCM_EXEC_FAILURE                                               : return "Failure attempting to launch OLE service";
    case CO_E_INIT_ONLY_SINGLE_THREADED                                           : return "There was an attempt to call CoInitialize a second time while single threaded";
    case CO_E_CANT_REMOTE                                                         : return "A Remote activation was necessary but was not allowed";
    case CO_E_BAD_SERVER_NAME                                                     : return "A Remote activation was necessary but the server name provided was invalid";
    case CO_E_WRONG_SERVER_IDENTITY                                               : return "The class is configured to run as a security id different from the caller";
    case CO_E_OLE1DDE_DISABLED                                                    : return "Use of Ole1 services requiring DDE windows is disabled";
    case CO_E_RUNAS_SYNTAX                                                        : return "A RunAs specification must be <domain name>\\<user name> or simply <user name>";
    case CO_E_CREATEPROCESS_FAILURE                                               : return "The server process could not be started. The pathname may be incorrect";
    case CO_E_RUNAS_CREATEPROCESS_FAILURE                                         : return "The server process could not be started as the configured identity. The pathname may be incorrect or unavailable";
    case CO_E_RUNAS_LOGON_FAILURE                                                 : return "The server process could not be started because the configured identity is incorrect. Check the username and password";
    case CO_E_LAUNCH_PERMSSION_DENIED                                             : return "The client is not allowed to launch this server";
    case CO_E_START_SERVICE_FAILURE                                               : return "The service providing this server could not be started";
    case CO_E_REMOTE_COMMUNICATION_FAILURE                                        : return "This computer was unable to communicate with the computer providing the server";
    case CO_E_SERVER_START_TIMEOUT                                                : return "The server did not respond after being launched";
    case CO_E_CLSREG_INCONSISTENT                                                 : return "The registration information for this server is inconsistent or incomplete";
    case CO_E_IIDREG_INCONSISTENT                                                 : return "The registration information for this interface is inconsistent or incomplete";
    case CO_E_NOT_SUPPORTED                                                       : return "The operation attempted is not supported";
    case CO_E_RELOAD_DLL                                                          : return "A dll must be loaded";
    case CO_E_MSI_ERROR                                                           : return "A Microsoft Software Installer error was encountered";
    case CO_E_ATTEMPT_TO_CREATE_OUTSIDE_CLIENT_CONTEXT                            : return "The specified activation could not occur in the client context as specified";
    case CO_E_SERVER_PAUSED                                                       : return "Activations on the server are paused";
    case CO_E_SERVER_NOT_PAUSED                                                   : return "Activations on the server are not paused";
    case CO_E_CLASS_DISABLED                                                      : return "The component or application containing the component has been disabled";
    case CO_E_CLRNOTAVAILABLE                                                     : return "The common language runtime is not available";
    case CO_E_ASYNC_WORK_REJECTED                                                 : return "The thread-pool rejected the submitted asynchronous work";
    case CO_E_SERVER_INIT_TIMEOUT                                                 : return "The server started, but did not finish initializing in a timely fashion";
    case CO_E_NO_SECCTX_IN_ACTIVATE                                               : return "Unable to complete the call since there is no COM+ security context inside IObjectControl.Activate";
    case CO_E_TRACKER_CONFIG                                                      : return "The provided tracker configuration is invalid";
    case CO_E_THREADPOOL_CONFIG                                                   : return "The provided thread pool configuration is invalid";
    case CO_E_SXS_CONFIG                                                          : return "The provided side-by-side configuration is invalid";
    case CO_E_MALFORMED_SPN                                                       : return "The server principal name (SPN) obtained during security negotiation is malformed";
    case CO_E_UNREVOKED_REGISTRATION_ON_APARTMENT_SHUTDOWN                        : return "The caller failed to revoke a per-apartment registration before apartment shutdown";
    case CO_E_PREMATURE_STUB_RUNDOWN                                              : return "The object has been rundown by the stub manager while there are external clients";
    case OLE_E_OLEVERB                                                            : return "Invalid OLEVERB structure";
    case OLE_E_ADVF                                                               : return "Invalid advise flags";
    case OLE_E_ENUM_NOMORE                                                        : return "Can't enumerate any more, because the associated data is missing";
    case OLE_E_ADVISENOTSUPPORTED                                                 : return "This implementation doesn't take advises";
    case OLE_E_NOCONNECTION                                                       : return "There is no connection for this connection ID";
    case OLE_E_NOTRUNNING                                                         : return "Need to run the object to perform this operation";
    case OLE_E_NOCACHE                                                            : return "There is no cache to operate on";
    case OLE_E_BLANK                                                              : return "Uninitialized object";
    case OLE_E_CLASSDIFF                                                          : return "Linked object's source class has changed";
    case OLE_E_CANT_GETMONIKER                                                    : return "Not able to get the moniker of the object";
    case OLE_E_CANT_BINDTOSOURCE                                                  : return "Not able to bind to the source";
    case OLE_E_STATIC                                                             : return "Object is static; operation not allowed";
    case OLE_E_PROMPTSAVECANCELLED                                                : return "User canceled out of save dialog";
    case OLE_E_INVALIDRECT                                                        : return "Invalid rectangle";
    case OLE_E_WRONGCOMPOBJ                                                       : return "compobj.dll is too old for the ole2.dll initialized";
    case OLE_E_INVALIDHWND                                                        : return "Invalid window handle";
    case OLE_E_NOT_INPLACEACTIVE                                                  : return "Object is not in any of the inplace active states";
    case OLE_E_CANTCONVERT                                                        : return "Not able to convert object";
    case OLE_E_NOSTORAGE                                                          : return "Not able to perform the operation because object is not given storage yet";
    case DV_E_FORMATETC                                                           : return "Invalid FORMATETC structure";
    case DV_E_DVTARGETDEVICE                                                      : return "Invalid DVTARGETDEVICE structure";
    case DV_E_STGMEDIUM                                                           : return "Invalid STDGMEDIUM structure";
    case DV_E_STATDATA                                                            : return "Invalid STATDATA structure";
    case DV_E_LINDEX                                                              : return "Invalid lindex";
    case DV_E_TYMED                                                               : return "Invalid tymed";
    case DV_E_CLIPFORMAT                                                          : return "Invalid clipboard format";
    case DV_E_DVASPECT                                                            : return "Invalid aspect(s)";
    case DV_E_DVTARGETDEVICE_SIZE                                                 : return "tdSize parameter of the DVTARGETDEVICE structure is invalid";
    case DV_E_NOIVIEWOBJECT                                                       : return "Object doesn't support IViewObject interface";
    case DRAGDROP_E_NOTREGISTERED                                                 : return "Trying to revoke a drop target that has not been registered";
    case DRAGDROP_E_ALREADYREGISTERED                                             : return "This window has already been registered as a drop target";
    case DRAGDROP_E_INVALIDHWND                                                   : return "Invalid window handle";
    case DRAGDROP_E_CONCURRENT_DRAG_ATTEMPTED                                     : return "A drag operation is already in progress";
    case CLASS_E_NOAGGREGATION                                                    : return "Class does not support aggregation (or class object is remote)";
    case CLASS_E_CLASSNOTAVAILABLE                                                : return "ClassFactory cannot supply requested class";
    case CLASS_E_NOTLICENSED                                                      : return "Class is not licensed for use";
    case VIEW_E_DRAW                                                              : return "Error drawing view";
    case REGDB_E_READREGDB                                                        : return "Could not read key from registry";
    case REGDB_E_WRITEREGDB                                                       : return "Could not write key to registry";
    case REGDB_E_KEYMISSING                                                       : return "Could not find the key in the registry";
    case REGDB_E_INVALIDVALUE                                                     : return "Invalid value for registry";
    case REGDB_E_CLASSNOTREG                                                      : return "Class not registered";
    case REGDB_E_IIDNOTREG                                                        : return "Interface not registered";
    case REGDB_E_BADTHREADINGMODEL                                                : return "Threading model entry is not valid";
    case REGDB_E_PACKAGEPOLICYVIOLATION                                           : return "A registration in a package violates package-specific policies";
    case CAT_E_CATIDNOEXIST                                                       : return "CATID does not exist";
    case CAT_E_NODESCRIPTION                                                      : return "Description not found";
    case CS_E_PACKAGE_NOTFOUND                                                    : return "No package in the software installation data in the Active Directory meets this criteria";
    case CS_E_NOT_DELETABLE                                                       : return "Deleting this will break the referential integrity of the software installation data in the Active Directory";
    case CS_E_CLASS_NOTFOUND                                                      : return "The CLSID was not found in the software installation data in the Active Directory";
    case CS_E_INVALID_VERSION                                                     : return "The software installation data in the Active Directory is corrupt";
    case CS_E_NO_CLASSSTORE                                                       : return "There is no software installation data in the Active Directory";
    case CS_E_OBJECT_NOTFOUND                                                     : return "There is no software installation data object in the Active Directory";
    case CS_E_OBJECT_ALREADY_EXISTS                                               : return "The software installation data object in the Active Directory already exists";
    case CS_E_INVALID_PATH                                                        : return "The path to the software installation data in the Active Directory is not correct";
    case CS_E_NETWORK_ERROR                                                       : return "A network error interrupted the operation";
    case CS_E_ADMIN_LIMIT_EXCEEDED                                                : return "The size of this object exceeds the maximum size set by the Administrator";
    case CS_E_SCHEMA_MISMATCH                                                     : return "The schema for the software installation data in the Active Directory does not match the required schema";
    case CS_E_INTERNAL_ERROR                                                      : return "An error occurred in the software installation data in the Active Directory";
    case CACHE_E_NOCACHE_UPDATED                                                  : return "Cache not updated";
    case OLEOBJ_E_NOVERBS                                                         : return "No verbs for OLE object";
    case OLEOBJ_E_INVALIDVERB                                                     : return "Invalid verb for OLE object";
    case INPLACE_E_NOTUNDOABLE                                                    : return "Undo is not available";
    case INPLACE_E_NOTOOLSPACE                                                    : return "Space for tools is not available";
    case CONVERT10_E_OLESTREAM_GET                                                : return "OLESTREAM Get method failed";
    case CONVERT10_E_OLESTREAM_PUT                                                : return "OLESTREAM Put method failed";
    case CONVERT10_E_OLESTREAM_FMT                                                : return "Contents of the OLESTREAM not in correct format";
    case CONVERT10_E_OLESTREAM_BITMAP_TO_DIB                                      : return "There was an error in a Windows GDI call while converting the bitmap to a DIB";
    case CONVERT10_E_STG_FMT                                                      : return "Contents of the IStorage not in correct format";
    case CONVERT10_E_STG_NO_STD_STREAM                                            : return "Contents of IStorage is missing one of the standard streams";
    case CONVERT10_E_STG_DIB_TO_BITMAP                                            : return "There was an error in a Windows GDI call while converting the DIB to a bitmap";
    case CLIPBRD_E_CANT_OPEN                                                      : return "OpenClipboard Failed";
    case CLIPBRD_E_CANT_EMPTY                                                     : return "EmptyClipboard Failed";
    case CLIPBRD_E_CANT_SET                                                       : return "SetClipboard Failed";
    case CLIPBRD_E_BAD_DATA                                                       : return "Data on clipboard is invalid";
    case CLIPBRD_E_CANT_CLOSE                                                     : return "CloseClipboard Failed";
    case MK_E_CONNECTMANUALLY                                                     : return "Moniker needs to be connected manually";
    case MK_E_EXCEEDEDDEADLINE                                                    : return "Operation exceeded deadline";
    case MK_E_NEEDGENERIC                                                         : return "Moniker needs to be generic";
    case MK_E_UNAVAILABLE                                                         : return "Operation unavailable";
    case MK_E_SYNTAX                                                              : return "Invalid syntax";
    case MK_E_NOOBJECT                                                            : return "No object for moniker";
    case MK_E_INVALIDEXTENSION                                                    : return "Bad extension for file";
    case MK_E_INTERMEDIATEINTERFACENOTSUPPORTED                                   : return "Intermediate operation failed";
    case MK_E_NOTBINDABLE                                                         : return "Moniker is not bindable";
    case MK_E_NOTBOUND                                                            : return "Moniker is not bound";
    case MK_E_CANTOPENFILE                                                        : return "Moniker cannot open file";
    case MK_E_MUSTBOTHERUSER                                                      : return "User input required for operation to succeed";
    case MK_E_NOINVERSE                                                           : return "Moniker class has no inverse";
    case MK_E_NOSTORAGE                                                           : return "Moniker does not refer to storage";
    case MK_E_NOPREFIX                                                            : return "No common prefix";
    case MK_E_ENUMERATION_FAILED                                                  : return "Moniker could not be enumerated";
    case CO_E_NOTINITIALIZED                                                      : return "CoInitialize has not been called";
    case CO_E_ALREADYINITIALIZED                                                  : return "CoInitialize has already been called";
    case CO_E_CANTDETERMINECLASS                                                  : return "Class of object cannot be determined";
    case CO_E_CLASSSTRING                                                         : return "Invalid class string";
    case CO_E_IIDSTRING                                                           : return "Invalid interface string";
    case CO_E_APPNOTFOUND                                                         : return "Application not found";
    case CO_E_APPSINGLEUSE                                                        : return "Application cannot be run more than once";
    case CO_E_ERRORINAPP                                                          : return "Some error in application program";
    case CO_E_DLLNOTFOUND                                                         : return "DLL for class not found";
    case CO_E_ERRORINDLL                                                          : return "Error in the DLL";
    case CO_E_WRONGOSFORAPP                                                       : return "Wrong OS or OS version for application";
    case CO_E_OBJNOTREG                                                           : return "Object is not registered";
    case CO_E_OBJISREG                                                            : return "Object is already registered";
    case CO_E_OBJNOTCONNECTED                                                     : return "Object is not connected to server";
    case CO_E_APPDIDNTREG                                                         : return "Application was launched but it didn't register a class factory";
    case CO_E_RELEASED                                                            : return "Object has been released";
    case EVENT_S_SOME_SUBSCRIBERS_FAILED                                          : return "An event was able to invoke some but not all of the subscribers";
    case EVENT_E_ALL_SUBSCRIBERS_FAILED                                           : return "An event was unable to invoke any of the subscribers";
    case EVENT_S_NOSUBSCRIBERS                                                    : return "An event was delivered but there were no subscribers";
    case EVENT_E_QUERYSYNTAX                                                      : return "A syntax error occurred trying to evaluate a query string";
    case EVENT_E_QUERYFIELD                                                       : return "An invalid field name was used in a query string";
    case EVENT_E_INTERNALEXCEPTION                                                : return "An unexpected exception was raised";
    case EVENT_E_INTERNALERROR                                                    : return "An unexpected internal error was detected";
    case EVENT_E_INVALID_PER_USER_SID                                             : return "The owner SID on a per-user subscription doesn't exist";
    case EVENT_E_USER_EXCEPTION                                                   : return "A user-supplied component or subscriber raised an exception";
    case EVENT_E_TOO_MANY_METHODS                                                 : return "An interface has too many methods to fire event from";
    case EVENT_E_MISSING_EVENTCLASS                                               : return "A subscription cannot be stored unless its event class already exists";
    case EVENT_E_NOT_ALL_REMOVED                                                  : return "Not all the objects requested could be removed";
    case EVENT_E_COMPLUS_NOT_INSTALLED                                            : return "COM+ is required for this operation, but is not installed";
    case EVENT_E_CANT_MODIFY_OR_DELETE_UNCONFIGURED_OBJECT                        : return "Cannot modify or delete an object that was not added using the COM+ Admin SDK";
    case EVENT_E_CANT_MODIFY_OR_DELETE_CONFIGURED_OBJECT                          : return "Cannot modify or delete an object that was added using the COM+ Admin SDK";
    case EVENT_E_INVALID_EVENT_CLASS_PARTITION                                    : return "The event class for this subscription is in an invalid partition";
    case EVENT_E_PER_USER_SID_NOT_LOGGED_ON                                       : return "The owner of the PerUser subscription is not logged on to the system specified";
    case TPC_E_INVALID_PROPERTY                                                   : return "TabletPC inking error code. The property was not found, or supported by the recognizer";
    case TPC_E_NO_DEFAULT_TABLET                                                  : return "TabletPC inking error code. No default tablet";
    case TPC_E_UNKNOWN_PROPERTY                                                   : return "TabletPC inking error code. Unknown property specified";
    case TPC_E_INVALID_INPUT_RECT                                                 : return "TabletPC inking error code. An invalid input rectangle was specified";
    case TPC_E_INVALID_STROKE                                                     : return "TabletPC inking error code. The stroke object was deleted";
    case TPC_E_INITIALIZE_FAIL                                                    : return "TabletPC inking error code. Initialization failure";
    case TPC_E_NOT_RELEVANT                                                       : return "TabletPC inking error code. The data required for the operation was not supplied";
    case TPC_E_INVALID_PACKET_DESCRIPTION                                         : return "TabletPC inking error code. Invalid packet description";
    case TPC_E_RECOGNIZER_NOT_REGISTERED                                          : return "TabletPC inking error code. There are no handwriting recognizers registered";
    case TPC_E_INVALID_RIGHTS                                                     : return "TabletPC inking error code. User does not have the necessary rights to read recognizer information";
    case TPC_E_OUT_OF_ORDER_CALL                                                  : return "TabletPC inking error code. API calls were made in an incorrect order";
    case TPC_E_QUEUE_FULL                                                         : return "TabletPC inking error code. Queue is full";
    case TPC_E_INVALID_CONFIGURATION                                              : return "TabletPC inking error code. RtpEnabled called multiple times";
    case TPC_E_INVALID_DATA_FROM_RECOGNIZER                                       : return "TabletPC inking error code. A recognizer returned invalid data";
    case TPC_S_TRUNCATED                                                          : return "TabletPC inking error code. String was truncated";
    case TPC_S_INTERRUPTED                                                        : return "TabletPC inking error code. Recognition or training was interrupted";
    case TPC_S_NO_DATA_TO_PROCESS                                                 : return "TabletPC inking error code. No personalization update to the recognizer because no training data found";
    case XACT_E_ALREADYOTHERSINGLEPHASE                                           : return "Another single phase resource manager has already been enlisted in this transaction";
    case XACT_E_CANTRETAIN                                                        : return "A retaining commit or abort is not supported";
    case XACT_E_COMMITFAILED                                                      : return "The transaction failed to commit for an unknown reason. The transaction was aborted";
    case XACT_E_COMMITPREVENTED                                                   : return "Cannot call commit on this transaction object because the calling application did not initiate the transaction";
    case XACT_E_HEURISTICABORT                                                    : return "Instead of committing, the resource heuristically aborted";
    case XACT_E_HEURISTICCOMMIT                                                   : return "Instead of aborting, the resource heuristically committed";
    case XACT_E_HEURISTICDAMAGE                                                   : return "Some of the states of the resource were committed while others were aborted, likely because of heuristic decisions";
    case XACT_E_HEURISTICDANGER                                                   : return "Some of the states of the resource may have been committed while others may have been aborted, likely because of heuristic decisions";
    case XACT_E_ISOLATIONLEVEL                                                    : return "The requested isolation level is not valid or supported";
    case XACT_E_NOASYNC                                                           : return "The transaction manager doesn't support an asynchronous operation for this method";
    case XACT_E_NOENLIST                                                          : return "Unable to enlist in the transaction";
    case XACT_E_NOISORETAIN                                                       : return "The requested semantics of retention of isolation across retaining commit and abort boundaries cannot be supported by this transaction implementation, or isoFlags was not equal to zero";
    case XACT_E_NORESOURCE                                                        : return "There is no resource presently associated with this enlistment";
    case XACT_E_NOTCURRENT                                                        : return "The transaction failed to commit due to the failure of optimistic concurrency control in at least one of the resource managers";
    case XACT_E_NOTRANSACTION                                                     : return "The transaction has already been implicitly or explicitly committed or aborted";
    case XACT_E_NOTSUPPORTED                                                      : return "An invalid combination of flags was specified";
    case XACT_E_UNKNOWNRMGRID                                                     : return "The resource manager id is not associated with this transaction or the transaction manager";
    case XACT_E_WRONGSTATE                                                        : return "This method was called in the wrong state";
    case XACT_E_WRONGUOW                                                          : return "The indicated unit of work does not match the unit of work expected by the resource manager";
    case XACT_E_XTIONEXISTS                                                       : return "An enlistment in a transaction already exists";
    case XACT_E_NOIMPORTOBJECT                                                    : return "An import object for the transaction could not be found";
    case XACT_E_INVALIDCOOKIE                                                     : return "The transaction cookie is invalid";
    case XACT_E_INDOUBT                                                           : return "The transaction status is in doubt. A communication failure occurred, or a transaction manager or resource manager has failed";
    case XACT_E_NOTIMEOUT                                                         : return "A time-out was specified, but time-outs are not supported";
    case XACT_E_ALREADYINPROGRESS                                                 : return "The requested operation is already in progress for the transaction";
    case XACT_E_ABORTED                                                           : return "The transaction has already been aborted";
    case XACT_E_LOGFULL                                                           : return "The Transaction Manager returned a log full error";
    case XACT_E_TMNOTAVAILABLE                                                    : return "The Transaction Manager is not available";
    case XACT_E_CONNECTION_DOWN                                                   : return "A connection with the transaction manager was lost";
    case XACT_E_CONNECTION_DENIED                                                 : return "A request to establish a connection with the transaction manager was denied";
    case XACT_E_REENLISTTIMEOUT                                                   : return "Resource manager reenlistment to determine transaction status timed out";
    case XACT_E_TIP_CONNECT_FAILED                                                : return "This transaction manager failed to establish a connection with another TIP transaction manager";
    case XACT_E_TIP_PROTOCOL_ERROR                                                : return "This transaction manager encountered a protocol error with another TIP transaction manager";
    case XACT_E_TIP_PULL_FAILED                                                   : return "This transaction manager could not propagate a transaction from another TIP transaction manager";
    case XACT_E_DEST_TMNOTAVAILABLE                                               : return "The Transaction Manager on the destination machine is not available";
    case XACT_E_TIP_DISABLED                                                      : return "The Transaction Manager has disabled its support for TIP";
    case XACT_E_NETWORK_TX_DISABLED                                               : return "The transaction manager has disabled its support for remote/network transactions";
    case XACT_E_PARTNER_NETWORK_TX_DISABLED                                       : return "The partner transaction manager has disabled its support for remote/network transactions";
    case XACT_E_XA_TX_DISABLED                                                    : return "The transaction manager has disabled its support for XA transactions";
    case XACT_E_UNABLE_TO_READ_DTC_CONFIG                                         : return "MSDTC was unable to read its configuration information";
    case XACT_E_UNABLE_TO_LOAD_DTC_PROXY                                          : return "MSDTC was unable to load the dtc proxy dll";
    case XACT_E_ABORTING                                                          : return "The local transaction has aborted";
    case XACT_E_PUSH_COMM_FAILURE                                                 : return "The MSDTC transaction manager was unable to push the transaction to the destination transaction manager due to communication problems. Possible causes are: a firewall is present and it doesn't have an exception for the MSDTC process, the two machines cannot find each other by their NetBIOS names, or the support for network transactions is not enabled for one of the two transaction managers";
    case XACT_E_PULL_COMM_FAILURE                                                 : return "The MSDTC transaction manager was unable to pull the transaction from the source transaction manager due to communication problems. Possible causes are: a firewall is present and it doesn't have an exception for the MSDTC process, the two machines cannot find each other by their NetBIOS names, or the support for network transactions is not enabled for one of the two transaction managers";
    case XACT_E_LU_TX_DISABLED                                                    : return "The MSDTC transaction manager has disabled its support for SNA LU 6.2 transactions";
    case XACT_E_CLERKNOTFOUND                                                     : return "XACT_E_CLERKNOTFOUND";
    case XACT_E_CLERKEXISTS                                                       : return "XACT_E_CLERKEXISTS";
    case XACT_E_RECOVERYINPROGRESS                                                : return "XACT_E_RECOVERYINPROGRESS";
    case XACT_E_TRANSACTIONCLOSED                                                 : return "XACT_E_TRANSACTIONCLOSED";
    case XACT_E_INVALIDLSN                                                        : return "XACT_E_INVALIDLSN";
    case XACT_E_REPLAYREQUEST                                                     : return "XACT_E_REPLAYREQUEST";
    case 0x8004D100                                                               : return "The request to connect to the specified transaction coordinator was denied";
    case 0x8004D101                                                               : return "The maximum number of enlistments for the specified transaction has been reached";
    case 0x8004D102                                                               : return "A resource manager with the same identifier is already registered with the specified transaction coordinator";
    case 0x8004D103                                                               : return "The prepare request given was not eligible for single phase optimizations";
    case 0x8004D104                                                               : return "RecoveryComplete has already been called for the given resource manager";
    case 0x8004D105                                                               : return "The interface call made was incorrect for the current state of the protocol";
    case 0x8004D106                                                               : return "xa_open call failed for the XA resource";
    case 0x8004D107                                                               : return "xa_recover call failed for the XA resource";
    case 0x8004D108                                                               : return "The Logical Unit of Work specified cannot be found";
    case 0x8004D109                                                               : return "The specified Logical Unit of Work already exists";
    case 0x8004D10A                                                               : return "Subordinate creation failed. The specified Logical Unit of Work was not connected";
    case 0x8004D10B                                                               : return "A transaction with the given identifier already exists";
    case 0x8004D10C                                                               : return "The resource is in use";
    case 0x8004D10D                                                               : return "The LU Recovery process is down";
    case 0x8004D10E                                                               : return "The remote session was lost";
    case 0x8004D10F                                                               : return "The resource is currently recovering";
    case 0x8004D110                                                               : return "There was a mismatch in driving recovery";
    case 0x8004D111                                                               : return "An error occurred with the XA resource";
    case XACT_S_ASYNC                                                             : return "An asynchronous operation was specified. The operation has begun, but its outcome is not known yet";
    case XACT_S_DEFECT                                                            : return "XACT_S_DEFECT";
    case XACT_S_READONLY                                                          : return "The method call succeeded because the transaction was read-only";
    case XACT_S_SOMENORETAIN                                                      : return "The transaction was successfully aborted. However, this is a coordinated transaction, and some number of enlisted resources were aborted outright because they could not support abort-retaining semantics";
    case XACT_S_OKINFORM                                                          : return "No changes were made during this call, but the sink wants another chance to look if any other sinks make further changes";
    case XACT_S_MADECHANGESCONTENT                                                : return "The sink is content and wishes the transaction to proceed. Changes were made to one or more resources during this call";
    case XACT_S_MADECHANGESINFORM                                                 : return "The sink is for the moment and wishes the transaction to proceed, but if other changes are made following this return by other event sinks then this sink wants another chance to look";
    case XACT_S_ALLNORETAIN                                                       : return "The transaction was successfully aborted. However, the abort was non-retaining";
    case XACT_S_ABORTING                                                          : return "An abort operation was already in progress";
    case XACT_S_SINGLEPHASE                                                       : return "The resource manager has performed a single-phase commit of the transaction";
    case XACT_S_LOCALLY_OK                                                        : return "The local transaction has not aborted";
    case XACT_S_LASTRESOURCEMANAGER                                               : return "The resource manager has requested to be the coordinator (last resource manager) for the transaction";
    case CONTEXT_E_ABORTED                                                        : return "The root transaction wanted to commit, but transaction aborted";
    case CONTEXT_E_ABORTING                                                       : return "You made a method call on a COM+ component that has a transaction that has already aborted or in the process of aborting";
    case CONTEXT_E_NOCONTEXT                                                      : return "There is no MTS object context";
    case CONTEXT_E_WOULD_DEADLOCK                                                 : return "The component is configured to use synchronization and this method call would cause a deadlock to occur";
    case CONTEXT_E_SYNCH_TIMEOUT                                                  : return "The component is configured to use synchronization and a thread has timed out waiting to enter the context";
    case CONTEXT_E_OLDREF                                                         : return "You made a method call on a COM+ component that has a transaction that has already committed or aborted";
    case CONTEXT_E_ROLENOTFOUND                                                   : return "The specified role was not configured for the application";
    case CONTEXT_E_TMNOTAVAILABLE                                                 : return "COM+ was unable to talk to the Microsoft Distributed Transaction Coordinator";
    case CO_E_ACTIVATIONFAILED                                                    : return "An unexpected error occurred during COM+ Activation";
    case CO_E_ACTIVATIONFAILED_EVENTLOGGED                                        : return "COM+ Activation failed. Check the event log for more information";
    case CO_E_ACTIVATIONFAILED_CATALOGERROR                                       : return "COM+ Activation failed due to a catalog or configuration error";
    case CO_E_ACTIVATIONFAILED_TIMEOUT                                            : return "COM+ activation failed because the activation could not be completed in the specified amount of time";
    case CO_E_INITIALIZATIONFAILED                                                : return "COM+ Activation failed because an initialization function failed. Check the event log for more information";
    case CONTEXT_E_NOJIT                                                          : return "The requested operation requires that JIT be in the current context and it is not";
    case CONTEXT_E_NOTRANSACTION                                                  : return "The requested operation requires that the current context have a Transaction, and it does not";
    case CO_E_THREADINGMODEL_CHANGED                                              : return "The components threading model has changed after install into a COM+ Application. Please re-install component";
    case CO_E_NOIISINTRINSICS                                                     : return "IIS intrinsics not available. Start your work with IIS";
    case CO_E_NOCOOKIES                                                           : return "An attempt to write a cookie failed";
    case CO_E_DBERROR                                                             : return "An attempt to use a database generated a database specific error";
    case CO_E_NOTPOOLED                                                           : return "The COM+ component you created must use object pooling to work";
    case CO_E_NOTCONSTRUCTED                                                      : return "The COM+ component you created must use object construction to work correctly";
    case CO_E_NOSYNCHRONIZATION                                                   : return "The COM+ component requires synchronization, and it is not configured for it";
    case CO_E_ISOLEVELMISMATCH                                                    : return "The TxIsolation Level property for the COM+ component being created is stronger than the TxIsolationLevel for the \"root\" component for the transaction. The creation failed";
    case CO_E_CALL_OUT_OF_TX_SCOPE_NOT_ALLOWED                                    : return "The component attempted to make a cross-context call between invocations of EnterTransactionScopeand ExitTransactionScope. This is not allowed. Cross-context calls cannot be made while inside of a transaction scope";
    case CO_E_EXIT_TRANSACTION_SCOPE_NOT_CALLED                                   : return "The component made a call to EnterTransactionScope, but did not make a corresponding call to ExitTransactionScope before returning";
    case OLE_S_USEREG                                                             : return "Use the registry database to provide the requested information";
    case OLE_S_STATIC                                                             : return "Success, but static";
    case OLE_S_MAC_CLIPFORMAT                                                     : return "Macintosh clipboard format";
    case DRAGDROP_S_DROP                                                          : return "Successful drop took place";
    case DRAGDROP_S_CANCEL                                                        : return "Drag-drop operation canceled";
    case DRAGDROP_S_USEDEFAULTCURSORS                                             : return "Use the default cursor";
    case DATA_S_SAMEFORMATETC                                                     : return "Data has same FORMATETC";
    case VIEW_S_ALREADY_FROZEN                                                    : return "View is already frozen";
    case CACHE_S_FORMATETC_NOTSUPPORTED                                           : return "FORMATETC not supported";
    case CACHE_S_SAMECACHE                                                        : return "Same cache";
    case CACHE_S_SOMECACHES_NOTUPDATED                                            : return "Some cache(s) not updated";
    case OLEOBJ_S_INVALIDVERB                                                     : return "Invalid verb for OLE object";
    case OLEOBJ_S_CANNOT_DOVERB_NOW                                               : return "Verb number is valid but verb cannot be done now";
    case OLEOBJ_S_INVALIDHWND                                                     : return "Invalid window handle passed";
    case INPLACE_S_TRUNCATED                                                      : return "Message is too long; some of it had to be truncated before displaying";
    case CONVERT10_S_NO_PRESENTATION                                              : return "Unable to convert OLESTREAM to IStorage";
    case MK_S_REDUCED_TO_SELF                                                     : return "Moniker reduced to itself";
    case MK_S_ME                                                                  : return "Common prefix is this moniker";
    case MK_S_HIM                                                                 : return "Common prefix is input moniker";
    case MK_S_US                                                                  : return "Common prefix is both monikers";
    case MK_S_MONIKERALREADYREGISTERED                                            : return "Moniker is already registered in running object table";
    case SCHED_S_TASK_READY                                                       : return "The task is ready to run at its next scheduled time";
    case SCHED_S_TASK_RUNNING                                                     : return "The task is currently running";
    case SCHED_S_TASK_DISABLED                                                    : return "The task will not run at the scheduled times because it has been disabled";
    case SCHED_S_TASK_HAS_NOT_RUN                                                 : return "The task has not yet run";
    case SCHED_S_TASK_NO_MORE_RUNS                                                : return "There are no more runs scheduled for this task";
    case SCHED_S_TASK_NOT_SCHEDULED                                               : return "One or more of the properties that are needed to run this task on a schedule have not been set";
    case SCHED_S_TASK_TERMINATED                                                  : return "The last run of the task was terminated by the user";
    case SCHED_S_TASK_NO_VALID_TRIGGERS                                           : return "Either the task has no triggers or the existing triggers are disabled or not set";
    case SCHED_S_EVENT_TRIGGER                                                    : return "Event triggers don't have set run times";
    case SCHED_E_TRIGGER_NOT_FOUND                                                : return "Trigger not found";
    case SCHED_E_TASK_NOT_READY                                                   : return "One or more of the properties that are needed to run this task have not been set";
    case SCHED_E_TASK_NOT_RUNNING                                                 : return "There is no running instance of the task";
    case SCHED_E_SERVICE_NOT_INSTALLED                                            : return "The Task Scheduler Service is not installed on this computer";
    case SCHED_E_CANNOT_OPEN_TASK                                                 : return "The task object could not be opened";
    case SCHED_E_INVALID_TASK                                                     : return "The object is either an invalid task object or is not a task object";
    case SCHED_E_ACCOUNT_INFORMATION_NOT_SET                                      : return "No account information could be found in the Task Scheduler security database for the task indicated";
    case SCHED_E_ACCOUNT_NAME_NOT_FOUND                                           : return "Unable to establish existence of the account specified";
    case SCHED_E_ACCOUNT_DBASE_CORRUPT                                            : return "Corruption was detected in the Task Scheduler security database; the database has been reset";
    case SCHED_E_NO_SECURITY_SERVICES                                             : return "Task Scheduler security services are available only on Windows NT";
    case SCHED_E_UNKNOWN_OBJECT_VERSION                                           : return "The task object version is either unsupported or invalid";
    case SCHED_E_UNSUPPORTED_ACCOUNT_OPTION                                       : return "The task has been configured with an unsupported combination of account settings and run time options";
    case SCHED_E_SERVICE_NOT_RUNNING                                              : return "The Task Scheduler Service is not running";
    case SCHED_E_UNEXPECTEDNODE                                                   : return "The task XML contains an unexpected node";
    case SCHED_E_NAMESPACE                                                        : return "The task XML contains an element or attribute from an unexpected namespace";
    case SCHED_E_INVALIDVALUE                                                     : return "The task XML contains a value which is incorrectly formatted or out of range";
    case SCHED_E_MISSINGNODE                                                      : return "The task XML is missing a required element or attribute";
    case SCHED_E_MALFORMEDXML                                                     : return "The task XML is malformed";
    case SCHED_S_SOME_TRIGGERS_FAILED                                             : return "The task is registered, but not all specified triggers will start the task, check task scheduler event log for detailed information";
    case SCHED_S_BATCH_LOGON_PROBLEM                                              : return "The task is registered, but may fail to start. Batch logon privilege needs to be enabled for the task principal";
    case SCHED_E_TOO_MANY_NODES                                                   : return "The task XML contains too many nodes of the same type";
    case SCHED_E_PAST_END_BOUNDARY                                                : return "The task cannot be started after the trigger's end boundary";
    case SCHED_E_ALREADY_RUNNING                                                  : return "An instance of this task is already running";
    case SCHED_E_USER_NOT_LOGGED_ON                                               : return "The task will not run because the user is not logged on";
    case SCHED_E_INVALID_TASK_HASH                                                : return "The task image is corrupt or has been tampered with";
    case SCHED_E_SERVICE_NOT_AVAILABLE                                            : return "The Task Scheduler service is not available";
    case SCHED_E_SERVICE_TOO_BUSY                                                 : return "The Task Scheduler service is too busy to handle your request. Please try again later";
    case SCHED_E_TASK_ATTEMPTED                                                   : return "The Task Scheduler service attempted to run the task, but the task did not run due to one of the constraints in the task definition";
    case SCHED_S_TASK_QUEUED                                                      : return "The Task Scheduler service has asked the task to run";
    case SCHED_E_TASK_DISABLED                                                    : return "The task is disabled";
    case SCHED_E_TASK_NOT_V1_COMPAT                                               : return "The task has properties that are not compatible with previous versions of Windows";
    case SCHED_E_START_ON_DEMAND                                                  : return "The task settings do not allow the task to start on demand";
    case SCHED_E_TASK_NOT_UBPM_COMPAT                                             : return "The combination of properties that task is using is not compatible with the scheduling engine";
    case SCHED_E_DEPRECATED_FEATURE_USED                                          : return "The task definition uses a deprecated feature";
    case CO_E_CLASS_CREATE_FAILED                                                 : return "Attempt to create a class object failed";
    case CO_E_SCM_ERROR                                                           : return "OLE service could not bind object";
    case CO_E_SCM_RPC_FAILURE                                                     : return "RPC communication failed with OLE service";
    case CO_E_BAD_PATH                                                            : return "Bad path to object";
    case CO_E_SERVER_EXEC_FAILURE                                                 : return "Server execution failed";
    case CO_E_OBJSRV_RPC_FAILURE                                                  : return "OLE service could not communicate with the object server";
    case MK_E_NO_NORMALIZED                                                       : return "Moniker path could not be normalized";
    case CO_E_SERVER_STOPPING                                                     : return "Object server is stopping when OLE service contacts it";
    case MEM_E_INVALID_ROOT                                                       : return "An invalid root block pointer was specified";
    case MEM_E_INVALID_LINK                                                       : return "An allocation chain contained an invalid link pointer";
    case MEM_E_INVALID_SIZE                                                       : return "The requested allocation size was too large";
    case CO_S_NOTALLINTERFACES                                                    : return "Not all the requested interfaces were available";
    case CO_S_MACHINENAMENOTFOUND                                                 : return "The specified machine name was not found in the cache";
    case CO_E_MISSING_DISPLAYNAME                                                 : return "The activation requires a display name to be present under the CLSID key";
    case CO_E_RUNAS_VALUE_MUST_BE_AAA                                             : return "The activation requires that the RunAs value for the application is Activate As Activator";
    case CO_E_ELEVATION_DISABLED                                                  : return "The class is not configured to support Elevated activation";
    case APPX_E_PACKAGING_INTERNAL                                                : return "Appx packaging API has encountered an internal error";
    case APPX_E_INTERLEAVING_NOT_ALLOWED                                          : return "The file is not a valid Appx package because its contents are interleaved";
    case APPX_E_RELATIONSHIPS_NOT_ALLOWED                                         : return "The file is not a valid Appx package because it contains OPC relationships";
    case APPX_E_MISSING_REQUIRED_FILE                                             : return "The file is not a valid Appx package because it is missing a manifest or block map, or missing a signature file when the code integrity file is present";
    case APPX_E_INVALID_MANIFEST                                                  : return "The Appx package's manifest is invalid";
    case APPX_E_INVALID_BLOCKMAP                                                  : return "The Appx package's block map is invalid";
    case APPX_E_CORRUPT_CONTENT                                                   : return "The Appx package's content cannot be read because it is corrupt";
    case APPX_E_BLOCK_HASH_INVALID                                                : return "The computed hash value of the block does not match the one stored in the block map";
    case APPX_E_REQUESTED_RANGE_TOO_LARGE                                         : return "The requested byte range is over 4GB when translated to byte range of blocks";
    case APPX_E_INVALID_SIP_CLIENT_DATA                                           : return "The SIP_SUBJECTINFO structure used to sign the package didn't contain the required data";
    case APPX_E_INVALID_KEY_INFO                                                  : return "The APPX_KEY_INFO structure used to encrypt or decrypt the package contains invalid data";
    case APPX_E_INVALID_CONTENTGROUPMAP                                           : return "The Appx package's content group map is invalid";
    case APPX_E_INVALID_APPINSTALLER                                              : return "The .appinstaller file is invalid";
    case BT_E_SPURIOUS_ACTIVATION                                                 : return "The background task activation is spurious";
    case DISP_E_UNKNOWNINTERFACE                                                  : return "Unknown interface";
    case DISP_E_MEMBERNOTFOUND                                                    : return "Member not found";
    case DISP_E_PARAMNOTFOUND                                                     : return "Parameter not found";
    case DISP_E_TYPEMISMATCH                                                      : return "Type mismatch";
    case DISP_E_UNKNOWNNAME                                                       : return "Unknown name";
    case DISP_E_NONAMEDARGS                                                       : return "No named arguments";
    case DISP_E_BADVARTYPE                                                        : return "Bad variable type";
    case DISP_E_EXCEPTION                                                         : return "Exception occurred";
    case DISP_E_OVERFLOW                                                          : return "Out of present range";
    case DISP_E_BADINDEX                                                          : return "Invalid index";
    case DISP_E_UNKNOWNLCID                                                       : return "Unknown language";
    case DISP_E_ARRAYISLOCKED                                                     : return "Memory is locked";
    case DISP_E_BADPARAMCOUNT                                                     : return "Invalid number of parameters";
    case DISP_E_PARAMNOTOPTIONAL                                                  : return "Parameter not optional";
    case DISP_E_BADCALLEE                                                         : return "Invalid callee";
    case DISP_E_NOTACOLLECTION                                                    : return "Does not support a collection";
    case DISP_E_DIVBYZERO                                                         : return "Division by zero";
    case DISP_E_BUFFERTOOSMALL                                                    : return "Buffer too small";
    case TYPE_E_BUFFERTOOSMALL                                                    : return "Buffer too small";
    case TYPE_E_FIELDNOTFOUND                                                     : return "Field name not defined in the record";
    case TYPE_E_INVDATAREAD                                                       : return "Old format or invalid type library";
    case TYPE_E_UNSUPFORMAT                                                       : return "Old format or invalid type library";
    case TYPE_E_REGISTRYACCESS                                                    : return "Error accessing the OLE registry";
    case TYPE_E_LIBNOTREGISTERED                                                  : return "Library not registered";
    case TYPE_E_UNDEFINEDTYPE                                                     : return "Bound to unknown type";
    case TYPE_E_QUALIFIEDNAMEDISALLOWED                                           : return "Qualified name disallowed";
    case TYPE_E_INVALIDSTATE                                                      : return "Invalid forward reference, or reference to uncompiled type";
    case TYPE_E_WRONGTYPEKIND                                                     : return "Type mismatch";
    case TYPE_E_ELEMENTNOTFOUND                                                   : return "Element not found";
    case TYPE_E_AMBIGUOUSNAME                                                     : return "Ambiguous name";
    case TYPE_E_NAMECONFLICT                                                      : return "Name already exists in the library";
    case TYPE_E_UNKNOWNLCID                                                       : return "Unknown LCID";
    case TYPE_E_DLLFUNCTIONNOTFOUND                                               : return "Function not defined in specified DLL";
    case TYPE_E_BADMODULEKIND                                                     : return "Wrong module kind for the operation";
    case TYPE_E_SIZETOOBIG                                                        : return "Size may not exceed 64K";
    case TYPE_E_DUPLICATEID                                                       : return "Duplicate ID in inheritance hierarchy";
    case TYPE_E_INVALIDID                                                         : return "Incorrect inheritance depth in standard OLE hmember";
    case TYPE_E_TYPEMISMATCH                                                      : return "Type mismatch";
    case TYPE_E_OUTOFBOUNDS                                                       : return "Invalid number of arguments";
    case TYPE_E_IOERROR                                                           : return "I/O Error";
    case TYPE_E_CANTCREATETMPFILE                                                 : return "Error creating unique tmp file";
    case TYPE_E_CANTLOADLIBRARY                                                   : return "Error loading type library/DLL";
    case TYPE_E_INCONSISTENTPROPFUNCS                                             : return "Inconsistent property functions";
    case TYPE_E_CIRCULARTYPE                                                      : return "Circular dependency between types/modules";
    case STG_E_INVALIDFUNCTION                                                    : return "Unable to perform requested operation";
    case STG_E_FILENOTFOUND                                                       : return "%1 could not be found";
    case STG_E_PATHNOTFOUND                                                       : return "The path %%1 could not be found";
    case STG_E_TOOMANYOPENFILES                                                   : return "There are insufficient resources to open another file";
    case STG_E_ACCESSDENIED                                                       : return "Access Denied";
    case STG_E_INVALIDHANDLE                                                      : return "Attempted an operation on an invalid object";
    case STG_E_INSUFFICIENTMEMORY                                                 : return "There is insufficient memory available to complete operation";
    case STG_E_INVALIDPOINTER                                                     : return "Invalid pointer error";
    case STG_E_NOMOREFILES                                                        : return "There are no more entries to return";
    case STG_E_DISKISWRITEPROTECTED                                               : return "Disk is write-protected";
    case STG_E_SEEKERROR                                                          : return "An error occurred during a seek operation";
    case STG_E_WRITEFAULT                                                         : return "A disk error occurred during a write operation";
    case STG_E_READFAULT                                                          : return "A disk error occurred during a read operation";
    case STG_E_SHAREVIOLATION                                                     : return "A share violation has occurred";
    case STG_E_LOCKVIOLATION                                                      : return "A lock violation has occurred";
    case STG_E_FILEALREADYEXISTS                                                  : return "%1 already exists";
    case STG_E_INVALIDPARAMETER                                                   : return "Invalid parameter error";
    case STG_E_MEDIUMFULL                                                         : return "There is insufficient disk space to complete operation";
    case STG_E_PROPSETMISMATCHED                                                  : return "Illegal write of non-simple property to simple property set";
    case STG_E_ABNORMALAPIEXIT                                                    : return "An API call exited abnormally";
    case STG_E_INVALIDHEADER                                                      : return "The file %%1 is not a valid compound file";
    case STG_E_INVALIDNAME                                                        : return "The name %%1 is not valid";
    case STG_E_UNKNOWN                                                            : return "An unexpected error occurred";
    case STG_E_UNIMPLEMENTEDFUNCTION                                              : return "That function is not implemented";
    case STG_E_INVALIDFLAG                                                        : return "Invalid flag error";
    case STG_E_INUSE                                                              : return "Attempted to use an object that is busy";
    case STG_E_NOTCURRENT                                                         : return "The storage has been changed since the last commit";
    case STG_E_REVERTED                                                           : return "Attempted to use an object that has ceased to exist";
    case STG_E_CANTSAVE                                                           : return "Can't save";
    case STG_E_OLDFORMAT                                                          : return "The compound file %%1 was produced with an incompatible version of storage";
    case STG_E_OLDDLL                                                             : return "The compound file %%1 was produced with a newer version of storage";
    case STG_E_SHAREREQUIRED                                                      : return "Share.exe or equivalent is required for operation";
    case STG_E_NOTFILEBASEDSTORAGE                                                : return "Illegal operation called on non-file based storage";
    case STG_E_EXTANTMARSHALLINGS                                                 : return "Illegal operation called on object with extant marshallings";
    case STG_E_DOCFILECORRUPT                                                     : return "The docfile has been corrupted";
    case STG_E_BADBASEADDRESS                                                     : return "OLE32.DLL has been loaded at the wrong address";
    case STG_E_DOCFILETOOLARGE                                                    : return "The compound file is too large for the current implementation";
    case STG_E_NOTSIMPLEFORMAT                                                    : return "The compound file was not created with the STGM_SIMPLE flag";
    case STG_E_INCOMPLETE                                                         : return "The file download was aborted abnormally. The file is incomplete";
    case STG_E_TERMINATED                                                         : return "The file download has been terminated";
    case STG_S_CONVERTED                                                          : return "The underlying file was converted to compound file format";
    case STG_S_BLOCK                                                              : return "The storage operation should block until more data is available";
    case STG_S_RETRYNOW                                                           : return "The storage operation should retry immediately";
    case STG_S_MONITORING                                                         : return "The notified event sink will not influence the storage operation";
    case STG_S_MULTIPLEOPENS                                                      : return "Multiple opens prevent consolidated. (commit succeeded)";
    case STG_S_CONSOLIDATIONFAILED                                                : return "Consolidation of the storage file failed. (commit succeeded)";
    case STG_S_CANNOTCONSOLIDATE                                                  : return "Consolidation of the storage file is inappropriate. (commit succeeded)";
    case STG_S_POWER_CYCLE_REQUIRED                                               : return "The device needs to be power cycled. (commit succeeded)";
    case STG_E_FIRMWARE_SLOT_INVALID                                              : return "The specified firmware slot is invalid";
    case STG_E_FIRMWARE_IMAGE_INVALID                                             : return "The specified firmware image is invalid";
    case STG_E_DEVICE_UNRESPONSIVE                                                : return "The storage device is unresponsive";
    case STG_E_STATUS_COPY_PROTECTION_FAILURE                                     : return "Generic Copy Protection Error";
    case STG_E_CSS_AUTHENTICATION_FAILURE                                         : return "Copy Protection Error - DVD CSS Authentication failed";
    case STG_E_CSS_KEY_NOT_PRESENT                                                : return "Copy Protection Error - The given sector does not have a valid CSS key";
    case STG_E_CSS_KEY_NOT_ESTABLISHED                                            : return "Copy Protection Error - DVD session key not established";
    case STG_E_CSS_SCRAMBLED_SECTOR                                               : return "Copy Protection Error - The read failed because the sector is encrypted";
    case STG_E_CSS_REGION_MISMATCH                                                : return "Copy Protection Error - The current DVD's region does not correspond to the region setting of the drive";
    case STG_E_RESETS_EXHAUSTED                                                   : return "Copy Protection Error - The drive's region setting may be permanent or the number of user resets has been exhausted";
    case RPC_E_CALL_REJECTED                                                      : return "Call was rejected by callee";
    case RPC_E_CALL_CANCELED                                                      : return "Call was canceled by the message filter";
    case RPC_E_CANTPOST_INSENDCALL                                                : return "The caller is dispatching an intertask SendMessage call and cannot call out via PostMessage";
    case RPC_E_CANTCALLOUT_INASYNCCALL                                            : return "The caller is dispatching an asynchronous call and cannot make an outgoing call on behalf of this call";
    case RPC_E_CANTCALLOUT_INEXTERNALCALL                                         : return "It is illegal to call out while inside message filter";
    case RPC_E_CONNECTION_TERMINATED                                              : return "The connection terminated or is in a bogus state and cannot be used any more. Other connections are still valid";
    case RPC_E_SERVER_DIED                                                        : return "The callee (server [not server application]) is not available and disappeared; all connections are invalid. The call may have executed";
    case RPC_E_CLIENT_DIED                                                        : return "The caller (client) disappeared while the callee (server) was processing a call";
    case RPC_E_INVALID_DATAPACKET                                                 : return "The data packet with the marshalled parameter data is incorrect";
    case RPC_E_CANTTRANSMIT_CALL                                                  : return "The call was not transmitted properly; the message queue was full and was not emptied after yielding";
    case RPC_E_CLIENT_CANTMARSHAL_DATA                                            : return "The client (caller) cannot marshall the parameter data - low memory, etc";
    case RPC_E_CLIENT_CANTUNMARSHAL_DATA                                          : return "The client (caller) cannot unmarshall the return data - low memory, etc";
    case RPC_E_SERVER_CANTMARSHAL_DATA                                            : return "The server (callee) cannot marshall the return data - low memory, etc";
    case RPC_E_SERVER_CANTUNMARSHAL_DATA                                          : return "The server (callee) cannot unmarshall the parameter data - low memory, etc";
    case RPC_E_INVALID_DATA                                                       : return "Received data is invalid; could be server or client data";
    case RPC_E_INVALID_PARAMETER                                                  : return "A particular parameter is invalid and cannot be (un)marshalled";
    case RPC_E_CANTCALLOUT_AGAIN                                                  : return "There is no second outgoing call on same channel in DDE conversation";
    case RPC_E_SERVER_DIED_DNE                                                    : return "The callee (server [not server application]) is not available and disappeared; all connections are invalid. The call did not execute";
    case RPC_E_SYS_CALL_FAILED                                                    : return "System call failed";
    case RPC_E_OUT_OF_RESOURCES                                                   : return "Could not allocate some required resource (memory, event, ...)";
    case RPC_E_ATTEMPTED_MULTITHREAD                                              : return "Attempted to make calls on more than one thread in single threaded mode";
    case RPC_E_NOT_REGISTERED                                                     : return "The requested interface is not registered on the server object";
    case RPC_E_FAULT                                                              : return "RPC could not call the server or could not return the results of calling the server";
    case RPC_E_SERVERFAULT                                                        : return "The server threw an exception";
    case RPC_E_CHANGED_MODE                                                       : return "Cannot change thread mode after it is set";
    case RPC_E_INVALIDMETHOD                                                      : return "The method called does not exist on the server";
    case RPC_E_DISCONNECTED                                                       : return "The object invoked has disconnected from its clients";
    case RPC_E_RETRY                                                              : return "The object invoked chose not to process the call now. Try again later";
    case RPC_E_SERVERCALL_RETRYLATER                                              : return "The message filter indicated that the application is busy";
    case RPC_E_SERVERCALL_REJECTED                                                : return "The message filter rejected the call";
    case RPC_E_INVALID_CALLDATA                                                   : return "A call control interfaces was called with invalid data";
    case RPC_E_CANTCALLOUT_ININPUTSYNCCALL                                        : return "An outgoing call cannot be made since the application is dispatching an input-synchronous call";
    case RPC_E_WRONG_THREAD                                                       : return "The application called an interface that was marshalled for a different thread";
    case RPC_E_THREAD_NOT_INIT                                                    : return "CoInitialize has not been called on the current thread";
    case RPC_E_VERSION_MISMATCH                                                   : return "The version of OLE on the client and server machines does not match";
    case RPC_E_INVALID_HEADER                                                     : return "OLE received a packet with an invalid header";
    case RPC_E_INVALID_EXTENSION                                                  : return "OLE received a packet with an invalid extension";
    case RPC_E_INVALID_IPID                                                       : return "The requested object or interface does not exist";
    case RPC_E_INVALID_OBJECT                                                     : return "The requested object does not exist";
    case RPC_S_CALLPENDING                                                        : return "OLE has sent a request and is waiting for a reply";
    case RPC_S_WAITONTIMER                                                        : return "OLE is waiting before retrying a request";
    case RPC_E_CALL_COMPLETE                                                      : return "Call context cannot be accessed after call completed";
    case RPC_E_UNSECURE_CALL                                                      : return "Impersonate on unsecure calls is not supported";
    case RPC_E_TOO_LATE                                                           : return "Security must be initialized before any interfaces are marshalled or unmarshalled. It cannot be changed once initialized";
    case RPC_E_NO_GOOD_SECURITY_PACKAGES                                          : return "No security packages are installed on this machine or the user is not logged on or there are no compatible security packages between the client and server";
    case RPC_E_ACCESS_DENIED                                                      : return "Access is denied";
    case RPC_E_REMOTE_DISABLED                                                    : return "Remote calls are not allowed for this process";
    case RPC_E_INVALID_OBJREF                                                     : return "The marshaled interface data packet (OBJREF) has an invalid or unknown format";
    case RPC_E_NO_CONTEXT                                                         : return "No context is associated with this call. This happens for some custom marshalled calls and on the client side of the call";
    case RPC_E_TIMEOUT                                                            : return "This operation returned because the timeout period expired";
    case RPC_E_NO_SYNC                                                            : return "There are no synchronize objects to wait on";
    case RPC_E_FULLSIC_REQUIRED                                                   : return "Full subject issuer chain SSL principal name expected from the server";
    case RPC_E_INVALID_STD_NAME                                                   : return "Principal name is not a valid MSSTD name";
    case CO_E_FAILEDTOIMPERSONATE                                                 : return "Unable to impersonate DCOM client";
    case CO_E_FAILEDTOGETSECCTX                                                   : return "Unable to obtain server's security context";
    case CO_E_FAILEDTOOPENTHREADTOKEN                                             : return "Unable to open the access token of the current thread";
    case CO_E_FAILEDTOGETTOKENINFO                                                : return "Unable to obtain user info from an access token";
    case CO_E_TRUSTEEDOESNTMATCHCLIENT                                            : return "The client who called IAccessControl::IsAccessPermitted was not the trustee provided to the method";
    case CO_E_FAILEDTOQUERYCLIENTBLANKET                                          : return "Unable to obtain the client's security blanket";
    case CO_E_FAILEDTOSETDACL                                                     : return "Unable to set a discretionary ACL into a security descriptor";
    case CO_E_ACCESSCHECKFAILED                                                   : return "The system function, AccessCheck, returned false";
    case CO_E_NETACCESSAPIFAILED                                                  : return "Either NetAccessDel or NetAccessAdd returned an error code";
    case CO_E_WRONGTRUSTEENAMESYNTAX                                              : return "One of the trustee strings provided by the user did not conform to the <Domain>\\<Name> syntax and it was not the \"*\" string";
    case CO_E_INVALIDSID                                                          : return "One of the security identifiers provided by the user was invalid";
    case CO_E_CONVERSIONFAILED                                                    : return "Unable to convert a wide character trustee string to a multibyte trustee string";
    case CO_E_NOMATCHINGSIDFOUND                                                  : return "Unable to find a security identifier that corresponds to a trustee string provided by the user";
    case CO_E_LOOKUPACCSIDFAILED                                                  : return "The system function, LookupAccountSID, failed";
    case CO_E_NOMATCHINGNAMEFOUND                                                 : return "Unable to find a trustee name that corresponds to a security identifier provided by the user";
    case CO_E_LOOKUPACCNAMEFAILED                                                 : return "The system function, LookupAccountName, failed";
    case CO_E_SETSERLHNDLFAILED                                                   : return "Unable to set or reset a serialization handle";
    case CO_E_FAILEDTOGETWINDIR                                                   : return "Unable to obtain the Windows directory";
    case CO_E_PATHTOOLONG                                                         : return "Path too long";
    case CO_E_FAILEDTOGENUUID                                                     : return "Unable to generate a uuid";
    case CO_E_FAILEDTOCREATEFILE                                                  : return "Unable to create file";
    case CO_E_FAILEDTOCLOSEHANDLE                                                 : return "Unable to close a serialization handle or a file handle";
    case CO_E_EXCEEDSYSACLLIMIT                                                   : return "The number of ACEs in an ACL exceeds the system limit";
    case CO_E_ACESINWRONGORDER                                                    : return "Not all the DENY_ACCESS ACEs are arranged in front of the GRANT_ACCESS ACEs in the stream";
    case CO_E_INCOMPATIBLESTREAMVERSION                                           : return "The version of ACL format in the stream is not supported by this implementation of IAccessControl";
    case CO_E_FAILEDTOOPENPROCESSTOKEN                                            : return "Unable to open the access token of the server process";
    case CO_E_DECODEFAILED                                                        : return "Unable to decode the ACL in the stream provided by the user";
    case CO_E_ACNOTINITIALIZED                                                    : return "The COM IAccessControl object is not initialized";
    case CO_E_CANCEL_DISABLED                                                     : return "Call Cancellation is disabled";
    case RPC_E_UNEXPECTED                                                         : return "An internal error occurred";
    case ERROR_AUDITING_DISABLED                                                  : return "The specified event is currently not being audited";
    case ERROR_ALL_SIDS_FILTERED                                                  : return "The SID filtering operation removed all SIDs";
    case ERROR_BIZRULES_NOT_ENABLED                                               : return "Business rule scripts are disabled for the calling application";
    case NTE_BAD_UID                                                              : return "Bad UID";
    case NTE_BAD_HASH                                                             : return "Bad Hash";
    case NTE_BAD_KEY                                                              : return "Bad Key";
    case NTE_BAD_LEN                                                              : return "Bad Length";
    case NTE_BAD_DATA                                                             : return "Bad Data";
    case NTE_BAD_SIGNATURE                                                        : return "Invalid Signature";
    case NTE_BAD_VER                                                              : return "Bad Version of provider";
    case NTE_BAD_ALGID                                                            : return "Invalid algorithm specified";
    case NTE_BAD_FLAGS                                                            : return "Invalid flags specified";
    case NTE_BAD_TYPE                                                             : return "Invalid type specified";
    case NTE_BAD_KEY_STATE                                                        : return "Key not valid for use in specified state";
    case NTE_BAD_HASH_STATE                                                       : return "Hash not valid for use in specified state";
    case NTE_NO_KEY                                                               : return "Key does not exist";
    case NTE_NO_MEMORY                                                            : return "Insufficient memory available for the operation";
    case NTE_EXISTS                                                               : return "Object already exists";
    case NTE_PERM                                                                 : return "Access denied";
    case NTE_NOT_FOUND                                                            : return "Object was not found";
    case NTE_DOUBLE_ENCRYPT                                                       : return "Data already encrypted";
    case NTE_BAD_PROVIDER                                                         : return "Invalid provider specified";
    case NTE_BAD_PROV_TYPE                                                        : return "Invalid provider type specified";
    case NTE_BAD_PUBLIC_KEY                                                       : return "Provider's public key is invalid";
    case NTE_BAD_KEYSET                                                           : return "Keyset does not exist";
    case NTE_PROV_TYPE_NOT_DEF                                                    : return "Provider type not defined";
    case NTE_PROV_TYPE_ENTRY_BAD                                                  : return "Provider type as registered is invalid";
    case NTE_KEYSET_NOT_DEF                                                       : return "The keyset is not defined";
    case NTE_KEYSET_ENTRY_BAD                                                     : return "Keyset as registered is invalid";
    case NTE_PROV_TYPE_NO_MATCH                                                   : return "Provider type does not match registered value";
    case NTE_SIGNATURE_FILE_BAD                                                   : return "The digital signature file is corrupt";
    case NTE_PROVIDER_DLL_FAIL                                                    : return "Provider DLL failed to initialize correctly";
    case NTE_PROV_DLL_NOT_FOUND                                                   : return "Provider DLL could not be found";
    case NTE_BAD_KEYSET_PARAM                                                     : return "The Keyset parameter is invalid";
    case NTE_FAIL                                                                 : return "An internal error occurred";
    case NTE_SYS_ERR                                                              : return "A base error occurred";
    case NTE_SILENT_CONTEXT                                                       : return "Provider could not perform the action since the context was acquired as silent";
    case NTE_TOKEN_KEYSET_STORAGE_FULL                                            : return "The security token does not have storage space available for an additional container";
    case NTE_TEMPORARY_PROFILE                                                    : return "The profile for the user is a temporary profile";
    case NTE_FIXEDPARAMETER                                                       : return "The key parameters could not be set because the CSP uses fixed parameters";
    case NTE_INVALID_HANDLE                                                       : return "The supplied handle is invalid";
    case NTE_INVALID_PARAMETER                                                    : return "The parameter is incorrect";
    case NTE_BUFFER_TOO_SMALL                                                     : return "The buffer supplied to a function was too small";
    case NTE_NOT_SUPPORTED                                                        : return "The requested operation is not supported";
    case NTE_NO_MORE_ITEMS                                                        : return "No more data is available";
    case NTE_BUFFERS_OVERLAP                                                      : return "The supplied buffers overlap incorrectly";
    case NTE_DECRYPTION_FAILURE                                                   : return "The specified data could not be decrypted";
    case NTE_INTERNAL_ERROR                                                       : return "An internal consistency check failed";
    case NTE_UI_REQUIRED                                                          : return "This operation requires input from the user";
    case NTE_HMAC_NOT_SUPPORTED                                                   : return "The cryptographic provider does not support HMAC";
    case NTE_DEVICE_NOT_READY                                                     : return "The device that is required by this cryptographic provider is not ready for use";
    case NTE_AUTHENTICATION_IGNORED                                               : return "The dictionary attack mitigation is triggered and the provided authorization was ignored by the provider";
    case NTE_VALIDATION_FAILED                                                    : return "The validation of the provided data failed the integrity or signature validation";
    case NTE_INCORRECT_PASSWORD                                                   : return "Incorrect password";
    case NTE_ENCRYPTION_FAILURE                                                   : return "Encryption failed";
    case NTE_DEVICE_NOT_FOUND                                                     : return "The device that is required by this cryptographic provider is not found on this platform";
    case NTE_USER_CANCELLED                                                       : return "The action was cancelled by the user";
    case NTE_PASSWORD_CHANGE_REQUIRED                                             : return "The password is no longer valid and must be changed";
    case NTE_NOT_ACTIVE_CONSOLE                                                   : return "The operation cannot be completed from Terminal Server client sessions";
    case SEC_E_INSUFFICIENT_MEMORY                                                : return "Not enough memory is available to complete this request";
    case SEC_E_INVALID_HANDLE                                                     : return "The handle specified is invalid";
    case SEC_E_UNSUPPORTED_FUNCTION                                               : return "The function requested is not supported";
    case SEC_E_TARGET_UNKNOWN                                                     : return "The specified target is unknown or unreachable";
    case SEC_E_INTERNAL_ERROR                                                     : return "The Local Security Authority cannot be contacted";
    case SEC_E_SECPKG_NOT_FOUND                                                   : return "The requested security package does not exist";
    case SEC_E_NOT_OWNER                                                          : return "The caller is not the owner of the desired credentials";
    case SEC_E_CANNOT_INSTALL                                                     : return "The security package failed to initialize, and cannot be installed";
    case SEC_E_INVALID_TOKEN                                                      : return "The token supplied to the function is invalid";
    case SEC_E_CANNOT_PACK                                                        : return "The security package is not able to marshall the logon buffer, so the logon attempt has failed";
    case SEC_E_QOP_NOT_SUPPORTED                                                  : return "The per-message Quality of Protection is not supported by the security package";
    case SEC_E_NO_IMPERSONATION                                                   : return "The security context does not allow impersonation of the client";
    case SEC_E_LOGON_DENIED                                                       : return "The logon attempt failed";
    case SEC_E_UNKNOWN_CREDENTIALS                                                : return "The credentials supplied to the package were not recognized";
    case SEC_E_NO_CREDENTIALS                                                     : return "No credentials are available in the security package";
    case SEC_E_MESSAGE_ALTERED                                                    : return "The message or signature supplied for verification has been altered";
    case SEC_E_OUT_OF_SEQUENCE                                                    : return "The message supplied for verification is out of sequence";
    case SEC_E_NO_AUTHENTICATING_AUTHORITY                                        : return "No authority could be contacted for authentication";
    case SEC_I_CONTINUE_NEEDED                                                    : return "The function completed successfully, but must be called again to complete the context";
    case SEC_I_COMPLETE_NEEDED                                                    : return "The function completed successfully, but CompleteToken must be called";
    case SEC_I_COMPLETE_AND_CONTINUE                                              : return "The function completed successfully, but both CompleteToken and this function must be called to complete the context";
    case SEC_I_LOCAL_LOGON                                                        : return "The logon was completed, but no network authority was available. The logon was made using locally known information";
    case SEC_E_BAD_PKGID                                                          : return "The requested security package does not exist";
    case SEC_E_CONTEXT_EXPIRED                                                    : return "The context has expired and can no longer be used";
    case SEC_I_CONTEXT_EXPIRED                                                    : return "The context has expired and can no longer be used";
    case SEC_E_INCOMPLETE_MESSAGE                                                 : return "The supplied message is incomplete. The signature was not verified";
    case SEC_E_INCOMPLETE_CREDENTIALS                                             : return "The credentials supplied were not complete, and could not be verified. The context could not be initialized";
    case SEC_E_BUFFER_TOO_SMALL                                                   : return "The buffers supplied to a function was too small";
    case SEC_I_INCOMPLETE_CREDENTIALS                                             : return "The credentials supplied were not complete, and could not be verified. Additional information can be returned from the context";
    case SEC_I_RENEGOTIATE                                                        : return "The context data must be renegotiated with the peer";
    case SEC_E_WRONG_PRINCIPAL                                                    : return "The target principal name is incorrect";
    case SEC_I_NO_LSA_CONTEXT                                                     : return "There is no LSA mode context associated with this context";
    case SEC_E_TIME_SKEW                                                          : return "The clocks on the client and server machines are skewed";
    case SEC_E_UNTRUSTED_ROOT                                                     : return "The certificate chain was issued by an authority that is not trusted";
    case SEC_E_ILLEGAL_MESSAGE                                                    : return "The message received was unexpected or badly formatted";
    case SEC_E_CERT_UNKNOWN                                                       : return "An unknown error occurred while processing the certificate";
    case SEC_E_CERT_EXPIRED                                                       : return "The received certificate has expired";
    case SEC_E_ENCRYPT_FAILURE                                                    : return "The specified data could not be encrypted";
    case SEC_E_DECRYPT_FAILURE                                                    : return "The specified data could not be decrypted";
    case SEC_E_ALGORITHM_MISMATCH                                                 : return "The client and server cannot communicate, because they do not possess a common algorithm";
    case SEC_E_SECURITY_QOS_FAILED                                                : return "The security context could not be established due to a failure in the requested quality of service (e.g. mutual authentication or delegation)";
    case SEC_E_UNFINISHED_CONTEXT_DELETED                                         : return "A security context was deleted before the context was completed. This is considered a logon failure";
    case SEC_E_NO_TGT_REPLY                                                       : return "The client is trying to negotiate a context and the server requires user-to-user but didn't send a TGT reply";
    case SEC_E_NO_IP_ADDRESSES                                                    : return "Unable to accomplish the requested task because the local machine does not have any IP addresses";
    case SEC_E_WRONG_CREDENTIAL_HANDLE                                            : return "The supplied credential handle does not match the credential associated with the security context";
    case SEC_E_CRYPTO_SYSTEM_INVALID                                              : return "The crypto system or checksum function is invalid because a required function is unavailable";
    case SEC_E_MAX_REFERRALS_EXCEEDED                                             : return "The number of maximum ticket referrals has been exceeded";
    case SEC_E_MUST_BE_KDC                                                        : return "The local machine must be a Kerberos KDC (domain controller) and it is not";
    case SEC_E_STRONG_CRYPTO_NOT_SUPPORTED                                        : return "The other end of the security negotiation is requires strong crypto but it is not supported on the local machine";
    case SEC_E_TOO_MANY_PRINCIPALS                                                : return "The KDC reply contained more than one principal name";
    case SEC_E_NO_PA_DATA                                                         : return "Expected to find PA data for a hint of what etype to use, but it was not found";
    case SEC_E_PKINIT_NAME_MISMATCH                                               : return "The client certificate does not contain a valid UPN, or does not match the client name in the logon request. Please contact your administrator";
    case SEC_E_SMARTCARD_LOGON_REQUIRED                                           : return "Smartcard logon is required and was not used";
    case SEC_E_SHUTDOWN_IN_PROGRESS                                               : return "A system shutdown is in progress";
    case SEC_E_KDC_INVALID_REQUEST                                                : return "An invalid request was sent to the KDC";
    case SEC_E_KDC_UNABLE_TO_REFER                                                : return "The KDC was unable to generate a referral for the service requested";
    case SEC_E_KDC_UNKNOWN_ETYPE                                                  : return "The encryption type requested is not supported by the KDC";
    case SEC_E_UNSUPPORTED_PREAUTH                                                : return "An unsupported preauthentication mechanism was presented to the Kerberos package";
    case SEC_E_DELEGATION_REQUIRED                                                : return "The requested operation cannot be completed. The computer must be trusted for delegation and the current user account must be configured to allow delegation";
    case SEC_E_BAD_BINDINGS                                                       : return "Client's supplied SSPI channel bindings were incorrect";
    case SEC_E_MULTIPLE_ACCOUNTS                                                  : return "The received certificate was mapped to multiple accounts";
    case SEC_E_NO_KERB_KEY                                                        : return "SEC_E_NO_KERB_KEY";
    case SEC_E_CERT_WRONG_USAGE                                                   : return "The certificate is not valid for the requested usage";
    case SEC_E_DOWNGRADE_DETECTED                                                 : return "The system cannot contact a domain controller to service the authentication request. Please try again later";
    case SEC_E_SMARTCARD_CERT_REVOKED                                             : return "The smartcard certificate used for authentication has been revoked. Please contact your system administrator. There may be additional information in the event log";
    case SEC_E_ISSUING_CA_UNTRUSTED                                               : return "An untrusted certificate authority was detected while processing the smartcard certificate used for authentication. Please contact your system administrator";
    case SEC_E_REVOCATION_OFFLINE_C                                               : return "The revocation status of the smartcard certificate used for authentication could not be determined. Please contact your system administrator";
    case SEC_E_PKINIT_CLIENT_FAILURE                                              : return "The smartcard certificate used for authentication was not trusted. Please contact your system administrator";
    case SEC_E_SMARTCARD_CERT_EXPIRED                                             : return "The smartcard certificate used for authentication has expired. Please contact your system administrator";
    case SEC_E_NO_S4U_PROT_SUPPORT                                                : return "The Kerberos subsystem encountered an error. A service for user protocol request was made against a domain controller which does not support service for user";
    case SEC_E_CROSSREALM_DELEGATION_FAILURE                                      : return "An attempt was made by this server to make a Kerberos constrained delegation request for a target outside of the server's realm. This is not supported, and indicates a misconfiguration on this server's allowed to delegate to list. Please contact your administrator";
    case SEC_E_REVOCATION_OFFLINE_KDC                                             : return "The revocation status of the domain controller certificate used for smartcard authentication could not be determined. There is additional information in the system event log. Please contact your system administrator";
    case SEC_E_ISSUING_CA_UNTRUSTED_KDC                                           : return "An untrusted certificate authority was detected while processing the domain controller certificate used for authentication. There is additional information in the system event log. Please contact your system administrator";
    case SEC_E_KDC_CERT_EXPIRED                                                   : return "The domain controller certificate used for smartcard logon has expired. Please contact your system administrator with the contents of your system event log";
    case SEC_E_KDC_CERT_REVOKED                                                   : return "The domain controller certificate used for smartcard logon has been revoked. Please contact your system administrator with the contents of your system event log";
    case SEC_I_SIGNATURE_NEEDED                                                   : return "A signature operation must be performed before the user can authenticate";
    case SEC_E_INVALID_PARAMETER                                                  : return "One or more of the parameters passed to the function was invalid";
    case SEC_E_DELEGATION_POLICY                                                  : return "Client policy does not allow credential delegation to target server";
    case SEC_E_POLICY_NLTM_ONLY                                                   : return "Client policy does not allow credential delegation to target server with NLTM only authentication";
    case SEC_I_NO_RENEGOTIATION                                                   : return "The recipient rejected the renegotiation request";
    case SEC_E_NO_CONTEXT                                                         : return "The required security context does not exist";
    case SEC_E_PKU2U_CERT_FAILURE                                                 : return "The PKU2U protocol encountered an error while attempting to utilize the associated certificates";
    case SEC_E_MUTUAL_AUTH_FAILED                                                 : return "The identity of the server computer could not be verified";
    case SEC_I_MESSAGE_FRAGMENT                                                   : return "The returned buffer is only a fragment of the message.  More fragments need to be returned";
    case SEC_E_ONLY_HTTPS_ALLOWED                                                 : return "Only https scheme is allowed";
    case SEC_I_CONTINUE_NEEDED_MESSAGE_OK                                         : return "The function completed successfully, but must be called again to complete the context.  Early start can be used";
    case SEC_E_APPLICATION_PROTOCOL_MISMATCH                                      : return "No common application protocol exists between the client and the server. Application protocol negotiation failed";
    case SEC_I_ASYNC_CALL_PENDING                                                 : return "An asynchronous SSPI routine has been called and the work is pending completion";
    case SEC_E_INVALID_UPN_NAME                                                   : return "You can't sign in with a user ID in this format. Try using your email address instead";
    case CRYPT_E_MSG_ERROR                                                        : return "An error occurred while performing an operation on a cryptographic message";
    case CRYPT_E_UNKNOWN_ALGO                                                     : return "Unknown cryptographic algorithm";
    case CRYPT_E_OID_FORMAT                                                       : return "The object identifier is poorly formatted";
    case CRYPT_E_INVALID_MSG_TYPE                                                 : return "Invalid cryptographic message type";
    case CRYPT_E_UNEXPECTED_ENCODING                                              : return "Unexpected cryptographic message encoding";
    case CRYPT_E_AUTH_ATTR_MISSING                                                : return "The cryptographic message does not contain an expected authenticated attribute";
    case CRYPT_E_HASH_VALUE                                                       : return "The hash value is not correct";
    case CRYPT_E_INVALID_INDEX                                                    : return "The index value is not valid";
    case CRYPT_E_ALREADY_DECRYPTED                                                : return "The content of the cryptographic message has already been decrypted";
    case CRYPT_E_NOT_DECRYPTED                                                    : return "The content of the cryptographic message has not been decrypted yet";
    case CRYPT_E_RECIPIENT_NOT_FOUND                                              : return "The enveloped-data message does not contain the specified recipient";
    case CRYPT_E_CONTROL_TYPE                                                     : return "Invalid control type";
    case CRYPT_E_ISSUER_SERIALNUMBER                                              : return "Invalid issuer and/or serial number";
    case CRYPT_E_SIGNER_NOT_FOUND                                                 : return "Cannot find the original signer";
    case CRYPT_E_ATTRIBUTES_MISSING                                               : return "The cryptographic message does not contain all of the requested attributes";
    case CRYPT_E_STREAM_MSG_NOT_READY                                             : return "The streamed cryptographic message is not ready to return data";
    case CRYPT_E_STREAM_INSUFFICIENT_DATA                                         : return "The streamed cryptographic message requires more data to complete the decode operation";
    case CRYPT_I_NEW_PROTECTION_REQUIRED                                          : return "The protected data needs to be re-protected";
    case CRYPT_E_BAD_LEN                                                          : return "The length specified for the output data was insufficient";
    case CRYPT_E_BAD_ENCODE                                                       : return "An error occurred during encode or decode operation";
    case CRYPT_E_FILE_ERROR                                                       : return "An error occurred while reading or writing to a file";
    case CRYPT_E_NOT_FOUND                                                        : return "Cannot find object or property";
    case CRYPT_E_EXISTS                                                           : return "The object or property already exists";
    case CRYPT_E_NO_PROVIDER                                                      : return "No provider was specified for the store or object";
    case CRYPT_E_SELF_SIGNED                                                      : return "The specified certificate is self signed";
    case CRYPT_E_DELETED_PREV                                                     : return "The previous certificate or CRL context was deleted";
    case CRYPT_E_NO_MATCH                                                         : return "Cannot find the requested object";
    case CRYPT_E_UNEXPECTED_MSG_TYPE                                              : return "The certificate does not have a property that references a private key";
    case CRYPT_E_NO_KEY_PROPERTY                                                  : return "Cannot find the certificate and private key for decryption";
    case CRYPT_E_NO_DECRYPT_CERT                                                  : return "Cannot find the certificate and private key to use for decryption";
    case CRYPT_E_BAD_MSG                                                          : return "Not a cryptographic message or the cryptographic message is not formatted correctly";
    case CRYPT_E_NO_SIGNER                                                        : return "The signed cryptographic message does not have a signer for the specified signer index";
    case CRYPT_E_PENDING_CLOSE                                                    : return "Final closure is pending until additional frees or closes";
    case CRYPT_E_REVOKED                                                          : return "The certificate is revoked";
    case CRYPT_E_NO_REVOCATION_DLL                                                : return "No Dll or exported function was found to verify revocation";
    case CRYPT_E_NO_REVOCATION_CHECK                                              : return "The revocation function was unable to check revocation for the certificate";
    case CRYPT_E_REVOCATION_OFFLINE                                               : return "The revocation function was unable to check revocation because the revocation server was offline";
    case CRYPT_E_NOT_IN_REVOCATION_DATABASE                                       : return "The certificate is not in the revocation server's database";
    case CRYPT_E_INVALID_NUMERIC_STRING                                           : return "The string contains a non-numeric character";
    case CRYPT_E_INVALID_PRINTABLE_STRING                                         : return "The string contains a non-printable character";
    case CRYPT_E_INVALID_IA5_STRING                                               : return "The string contains a character not in the 7 bit ASCII character set";
    case CRYPT_E_INVALID_X500_STRING                                              : return "The string contains an invalid X500 name attribute key, oid, value or delimiter";
    case CRYPT_E_NOT_CHAR_STRING                                                  : return "The dwValueType for the CERT_NAME_VALUE is not one of the character strings. Most likely it is either a CERT_RDN_ENCODED_BLOB or CERT_RDN_OCTET_STRING";
    case CRYPT_E_FILERESIZED                                                      : return "The Put operation cannot continue. The file needs to be resized. However, there is already a signature present. A complete signing operation must be done";
    case CRYPT_E_SECURITY_SETTINGS                                                : return "The cryptographic operation failed due to a local security option setting";
    case CRYPT_E_NO_VERIFY_USAGE_DLL                                              : return "No DLL or exported function was found to verify subject usage";
    case CRYPT_E_NO_VERIFY_USAGE_CHECK                                            : return "The called function was unable to do a usage check on the subject";
    case CRYPT_E_VERIFY_USAGE_OFFLINE                                             : return "Since the server was offline, the called function was unable to complete the usage check";
    case CRYPT_E_NOT_IN_CTL                                                       : return "The subject was not found in a Certificate Trust List (CTL)";
    case CRYPT_E_NO_TRUSTED_SIGNER                                                : return "None of the signers of the cryptographic message or certificate trust list is trusted";
    case CRYPT_E_MISSING_PUBKEY_PARA                                              : return "The public key's algorithm parameters are missing";
    case CRYPT_E_OBJECT_LOCATOR_OBJECT_NOT_FOUND                                  : return "An object could not be located using the object locator infrastructure with the given name";
    case CRYPT_E_OSS_ERROR                                                        : return "OSS Certificate encode/decode error code base";
    case OSS_MORE_BUF                                                             : return "OSS ASN.1 Error: Output Buffer is too small";
    case OSS_NEGATIVE_UINTEGER                                                    : return "OSS ASN.1 Error: Signed integer is encoded as a unsigned integer";
    case OSS_PDU_RANGE                                                            : return "OSS ASN.1 Error: Unknown ASN.1 data type";
    case OSS_MORE_INPUT                                                           : return "OSS ASN.1 Error: Output buffer is too small, the decoded data has been truncated";
    case OSS_DATA_ERROR                                                           : return "OSS ASN.1 Error: Invalid data";
    case OSS_BAD_ARG                                                              : return "OSS ASN.1 Error: Invalid argument";
    case OSS_BAD_VERSION                                                          : return "OSS ASN.1 Error: Encode/Decode version mismatch";
    case OSS_OUT_MEMORY                                                           : return "OSS ASN.1 Error: Out of memory";
    case OSS_PDU_MISMATCH                                                         : return "OSS ASN.1 Error: Encode/Decode Error";
    case OSS_LIMITED                                                              : return "OSS ASN.1 Error: Internal Error";
    case OSS_BAD_PTR                                                              : return "OSS ASN.1 Error: Invalid data";
    case OSS_BAD_TIME                                                             : return "OSS ASN.1 Error: Invalid data";
    case OSS_INDEFINITE_NOT_SUPPORTED                                             : return "OSS ASN.1 Error: Unsupported BER indefinite-length encoding";
    case OSS_MEM_ERROR                                                            : return "OSS ASN.1 Error: Access violation";
    case OSS_BAD_TABLE                                                            : return "OSS ASN.1 Error: Invalid data";
    case OSS_TOO_LONG                                                             : return "OSS ASN.1 Error: Invalid data";
    case OSS_CONSTRAINT_VIOLATED                                                  : return "OSS ASN.1 Error: Invalid data";
    case OSS_FATAL_ERROR                                                          : return "OSS ASN.1 Error: Internal Error";
    case OSS_ACCESS_SERIALIZATION_ERROR                                           : return "OSS ASN.1 Error: Multi-threading conflict";
    case OSS_NULL_TBL                                                             : return "OSS ASN.1 Error: Invalid data";
    case OSS_NULL_FCN                                                             : return "OSS ASN.1 Error: Invalid data";
    case OSS_BAD_ENCRULES                                                         : return "OSS ASN.1 Error: Invalid data";
    case OSS_UNAVAIL_ENCRULES                                                     : return "OSS ASN.1 Error: Encode/Decode function not implemented";
    case OSS_CANT_OPEN_TRACE_WINDOW                                               : return "OSS ASN.1 Error: Trace file error";
    case OSS_UNIMPLEMENTED                                                        : return "OSS ASN.1 Error: Function not implemented";
    case OSS_OID_DLL_NOT_LINKED                                                   : return "OSS ASN.1 Error: Program link error";
    case OSS_CANT_OPEN_TRACE_FILE                                                 : return "OSS ASN.1 Error: Trace file error";
    case OSS_TRACE_FILE_ALREADY_OPEN                                              : return "OSS ASN.1 Error: Trace file error";
    case OSS_TABLE_MISMATCH                                                       : return "OSS ASN.1 Error: Invalid data";
    case OSS_TYPE_NOT_SUPPORTED                                                   : return "OSS ASN.1 Error: Invalid data";
    case OSS_REAL_DLL_NOT_LINKED                                                  : return "OSS ASN.1 Error: Program link error";
    case OSS_REAL_CODE_NOT_LINKED                                                 : return "OSS ASN.1 Error: Program link error";
    case OSS_OUT_OF_RANGE                                                         : return "OSS ASN.1 Error: Program link error";
    case OSS_COPIER_DLL_NOT_LINKED                                                : return "OSS ASN.1 Error: Program link error";
    case OSS_CONSTRAINT_DLL_NOT_LINKED                                            : return "OSS ASN.1 Error: Program link error";
    case OSS_COMPARATOR_DLL_NOT_LINKED                                            : return "OSS ASN.1 Error: Program link error";
    case OSS_COMPARATOR_CODE_NOT_LINKED                                           : return "OSS ASN.1 Error: Program link error";
    case OSS_MEM_MGR_DLL_NOT_LINKED                                               : return "OSS ASN.1 Error: Program link error";
    case OSS_PDV_DLL_NOT_LINKED                                                   : return "OSS ASN.1 Error: Program link error";
    case OSS_PDV_CODE_NOT_LINKED                                                  : return "OSS ASN.1 Error: Program link error";
    case OSS_API_DLL_NOT_LINKED                                                   : return "OSS ASN.1 Error: Program link error";
    case OSS_BERDER_DLL_NOT_LINKED                                                : return "OSS ASN.1 Error: Program link error";
    case OSS_PER_DLL_NOT_LINKED                                                   : return "OSS ASN.1 Error: Program link error";
    case OSS_OPEN_TYPE_ERROR                                                      : return "OSS ASN.1 Error: Program link error";
    case OSS_MUTEX_NOT_CREATED                                                    : return "OSS ASN.1 Error: System resource error";
    case OSS_CANT_CLOSE_TRACE_FILE                                                : return "OSS ASN.1 Error: Trace file error";
    case CRYPT_E_ASN1_ERROR                                                       : return "ASN1 Certificate encode/decode error code base. The ASN1 error values are offset by CRYPT_E_ASN1_ERROR";
    case CRYPT_E_ASN1_INTERNAL                                                    : return "ASN1 internal encode or decode error";
    case CRYPT_E_ASN1_EOD                                                         : return "ASN1 unexpected end of data";
    case CRYPT_E_ASN1_CORRUPT                                                     : return "ASN1 corrupted data";
    case CRYPT_E_ASN1_LARGE                                                       : return "ASN1 value too large";
    case CRYPT_E_ASN1_CONSTRAINT                                                  : return "ASN1 constraint violated";
    case CRYPT_E_ASN1_MEMORY                                                      : return "ASN1 out of memory";
    case CRYPT_E_ASN1_OVERFLOW                                                    : return "ASN1 buffer overflow";
    case CRYPT_E_ASN1_BADPDU                                                      : return "ASN1 function not supported for this PDU";
    case CRYPT_E_ASN1_BADARGS                                                     : return "ASN1 bad arguments to function call";
    case CRYPT_E_ASN1_BADREAL                                                     : return "ASN1 bad real value";
    case CRYPT_E_ASN1_BADTAG                                                      : return "ASN1 bad tag value met";
    case CRYPT_E_ASN1_CHOICE                                                      : return "ASN1 bad choice value";
    case CRYPT_E_ASN1_RULE                                                        : return "ASN1 bad encoding rule";
    case CRYPT_E_ASN1_UTF8                                                        : return "ASN1 bad unicode (UTF8)";
    case CRYPT_E_ASN1_PDU_TYPE                                                    : return "ASN1 bad PDU type";
    case CRYPT_E_ASN1_NYI                                                         : return "ASN1 not yet implemented";
    case CRYPT_E_ASN1_EXTENDED                                                    : return "ASN1 skipped unknown extension(s)";
    case CRYPT_E_ASN1_NOEOD                                                       : return "ASN1 end of data expected";
    case CERTSRV_E_BAD_REQUESTSUBJECT                                             : return "The request subject name is invalid or too long";
    case CERTSRV_E_NO_REQUEST                                                     : return "The request does not exist";
    case CERTSRV_E_BAD_REQUESTSTATUS                                              : return "The request's current status does not allow this operation";
    case CERTSRV_E_PROPERTY_EMPTY                                                 : return "The requested property value is empty";
    case CERTSRV_E_INVALID_CA_CERTIFICATE                                         : return "The certification authority's certificate contains invalid data";
    case CERTSRV_E_SERVER_SUSPENDED                                               : return "Certificate service has been suspended for a database restore operation";
    case CERTSRV_E_ENCODING_LENGTH                                                : return "The certificate contains an encoded length that is potentially incompatible with older enrollment software";
    case CERTSRV_E_ROLECONFLICT                                                   : return "The operation is denied. The user has multiple roles assigned and the certification authority is configured to enforce role separation";
    case CERTSRV_E_RESTRICTEDOFFICER                                              : return "The operation is denied. It can only be performed by a certificate manager that is allowed to manage certificates for the current requester";
    case CERTSRV_E_KEY_ARCHIVAL_NOT_CONFIGURED                                    : return "Cannot archive private key. The certification authority is not configured for key archival";
    case CERTSRV_E_NO_VALID_KRA                                                   : return "Cannot archive private key. The certification authority could not verify one or more key recovery certificates";
    case CERTSRV_E_BAD_REQUEST_KEY_ARCHIVAL                                       : return "The request is incorrectly formatted. The encrypted private key must be in an unauthenticated attribute in an outermost signature";
    case CERTSRV_E_NO_CAADMIN_DEFINED                                             : return "At least one security principal must have the permission to manage this CA";
    case CERTSRV_E_BAD_RENEWAL_CERT_ATTRIBUTE                                     : return "The request contains an invalid renewal certificate attribute";
    case CERTSRV_E_NO_DB_SESSIONS                                                 : return "An attempt was made to open a Certification Authority database session, but there are already too many active sessions. The server may need to be configured to allow additional sessions";
    case CERTSRV_E_ALIGNMENT_FAULT                                                : return "A memory reference caused a data alignment fault";
    case CERTSRV_E_ENROLL_DENIED                                                  : return "The permissions on this certification authority do not allow the current user to enroll for certificates";
    case CERTSRV_E_TEMPLATE_DENIED                                                : return "The permissions on the certificate template do not allow the current user to enroll for this type of certificate";
    case CERTSRV_E_DOWNLEVEL_DC_SSL_OR_UPGRADE                                    : return "The contacted domain controller cannot support signed LDAP traffic. Update the domain controller or configure Certificate Services to use SSL for Active Directory access";
    case CERTSRV_E_ADMIN_DENIED_REQUEST                                           : return "The request was denied by a certificate manager or CA administrator";
    case CERTSRV_E_NO_POLICY_SERVER                                               : return "An enrollment policy server cannot be located";
    case CERTSRV_E_WEAK_SIGNATURE_OR_KEY                                          : return "A signature algorithm or public key length does not meet the system's minimum required strength";
    case CERTSRV_E_KEY_ATTESTATION_NOT_SUPPORTED                                  : return "Failed to create an attested key.  This computer or the cryptographic provider may not meet the hardware requirements to support key attestation";
    case CERTSRV_E_ENCRYPTION_CERT_REQUIRED                                       : return "No encryption certificate was specified";
    case CERTSRV_E_UNSUPPORTED_CERT_TYPE                                          : return "The requested certificate template is not supported by this CA";
    case CERTSRV_E_NO_CERT_TYPE                                                   : return "The request contains no certificate template information";
    case CERTSRV_E_TEMPLATE_CONFLICT                                              : return "The request contains conflicting template information";
    case CERTSRV_E_SUBJECT_ALT_NAME_REQUIRED                                      : return "The request is missing a required Subject Alternate name extension";
    case CERTSRV_E_ARCHIVED_KEY_REQUIRED                                          : return "The request is missing a required private key for archival by the server";
    case CERTSRV_E_SMIME_REQUIRED                                                 : return "The request is missing a required SMIME capabilities extension";
    case CERTSRV_E_BAD_RENEWAL_SUBJECT                                            : return "The request was made on behalf of a subject other than the caller. The certificate template must be configured to require at least one signature to authorize the request";
    case CERTSRV_E_BAD_TEMPLATE_VERSION                                           : return "The request template version is newer than the supported template version";
    case CERTSRV_E_TEMPLATE_POLICY_REQUIRED                                       : return "The template is missing a required signature policy attribute";
    case CERTSRV_E_SIGNATURE_POLICY_REQUIRED                                      : return "The request is missing required signature policy information";
    case CERTSRV_E_SIGNATURE_COUNT                                                : return "The request is missing one or more required signatures";
    case CERTSRV_E_SIGNATURE_REJECTED                                             : return "One or more signatures did not include the required application or issuance policies. The request is missing one or more required valid signatures";
    case CERTSRV_E_ISSUANCE_POLICY_REQUIRED                                       : return "The request is missing one or more required signature issuance policies";
    case CERTSRV_E_SUBJECT_UPN_REQUIRED                                           : return "The UPN is unavailable and cannot be added to the Subject Alternate name";
    case CERTSRV_E_SUBJECT_DIRECTORY_GUID_REQUIRED                                : return "The Active Directory GUID is unavailable and cannot be added to the Subject Alternate name";
    case CERTSRV_E_SUBJECT_DNS_REQUIRED                                           : return "The DNS name is unavailable and cannot be added to the Subject Alternate name";
    case CERTSRV_E_ARCHIVED_KEY_UNEXPECTED                                        : return "The request includes a private key for archival by the server, but key archival is not enabled for the specified certificate template";
    case CERTSRV_E_KEY_LENGTH                                                     : return "The public key does not meet the minimum size required by the specified certificate template";
    case CERTSRV_E_SUBJECT_EMAIL_REQUIRED                                         : return "The EMail name is unavailable and cannot be added to the Subject or Subject Alternate name";
    case CERTSRV_E_UNKNOWN_CERT_TYPE                                              : return "One or more certificate templates to be enabled on this certification authority could not be found";
    case CERTSRV_E_CERT_TYPE_OVERLAP                                              : return "The certificate template renewal period is longer than the certificate validity period. The template should be reconfigured or the CA certificate renewed";
    case CERTSRV_E_TOO_MANY_SIGNATURES                                            : return "The certificate template requires too many RA signatures. Only one RA signature is allowed";
    case CERTSRV_E_RENEWAL_BAD_PUBLIC_KEY                                         : return "The certificate template requires renewal with the same public key, but the request uses a different public key";
    case CERTSRV_E_INVALID_EK                                                     : return "The certification authority cannot interpret or verify the endorsement key information supplied in the request, or the information is inconsistent";
    case CERTSRV_E_INVALID_IDBINDING                                              : return "The certification authority cannot validate the Attestation Identity Key Id Binding";
    case CERTSRV_E_INVALID_ATTESTATION                                            : return "The certification authority cannot validate the private key attestation data";
    case CERTSRV_E_KEY_ATTESTATION                                                : return "The request does not support private key attestation as defined in the certificate template";
    case CERTSRV_E_CORRUPT_KEY_ATTESTATION                                        : return "The request public key is not consistent with the private key attestation data";
    case CERTSRV_E_EXPIRED_CHALLENGE                                              : return "The private key attestation challenge cannot be validated because the encryption certificate has expired, or the certificate or key is unavailable";
    case CERTSRV_E_INVALID_RESPONSE                                               : return "The attestation response could not be validated. It is either unexpected or incorrect";
    case CERTSRV_E_INVALID_REQUESTID                                              : return "A valid Request ID was not detected in the request attributes, or an invalid one was submitted";
    case XENROLL_E_KEY_NOT_EXPORTABLE                                             : return "The key is not exportable";
    case XENROLL_E_CANNOT_ADD_ROOT_CERT                                           : return "You cannot add the root CA certificate into your local store";
    case XENROLL_E_RESPONSE_KA_HASH_NOT_FOUND                                     : return "The key archival hash attribute was not found in the response";
    case XENROLL_E_RESPONSE_UNEXPECTED_KA_HASH                                    : return "An unexpected key archival hash attribute was found in the response";
    case XENROLL_E_RESPONSE_KA_HASH_MISMATCH                                      : return "There is a key archival hash mismatch between the request and the response";
    case XENROLL_E_KEYSPEC_SMIME_MISMATCH                                         : return "Signing certificate cannot include SMIME extension";
    case TRUST_E_SYSTEM_ERROR                                                     : return "A system-level error occurred while verifying trust";
    case TRUST_E_NO_SIGNER_CERT                                                   : return "The certificate for the signer of the message is invalid or not found";
    case TRUST_E_COUNTER_SIGNER                                                   : return "One of the counter signatures was invalid";
    case TRUST_E_CERT_SIGNATURE                                                   : return "The signature of the certificate cannot be verified";
    case TRUST_E_TIME_STAMP                                                       : return "The timestamp signature and/or certificate could not be verified or is malformed";
    case TRUST_E_BAD_DIGEST                                                       : return "The digital signature of the object did not verify";
    case TRUST_E_MALFORMED_SIGNATURE                                              : return "The digital signature of the object is malformed. For technical detail, see security bulletin MS13-098";
    case TRUST_E_BASIC_CONSTRAINTS                                                : return "A certificate's basic constraint extension has not been observed";
    case TRUST_E_FINANCIAL_CRITERIA                                               : return "The certificate does not meet or contain the Authenticode(tm) financial extensions";
    case MSSIPOTF_E_OUTOFMEMRANGE                                                 : return "Tried to reference a part of the file outside the proper range";
    case MSSIPOTF_E_CANTGETOBJECT                                                 : return "Could not retrieve an object from the file";
    case MSSIPOTF_E_NOHEADTABLE                                                   : return "Could not find the head table in the file";
    case MSSIPOTF_E_BAD_MAGICNUMBER                                               : return "The magic number in the head table is incorrect";
    case MSSIPOTF_E_BAD_OFFSET_TABLE                                              : return "The offset table has incorrect values";
    case MSSIPOTF_E_TABLE_TAGORDER                                                : return "Duplicate table tags or tags out of alphabetical order";
    case MSSIPOTF_E_TABLE_LONGWORD                                                : return "A table does not start on a long word boundary";
    case MSSIPOTF_E_BAD_FIRST_TABLE_PLACEMENT                                     : return "First table does not appear after header information";
    case MSSIPOTF_E_TABLES_OVERLAP                                                : return "Two or more tables overlap";
    case MSSIPOTF_E_TABLE_PADBYTES                                                : return "Too many pad bytes between tables or pad bytes are not 0";
    case MSSIPOTF_E_FILETOOSMALL                                                  : return "File is too small to contain the last table";
    case MSSIPOTF_E_TABLE_CHECKSUM                                                : return "A table checksum is incorrect";
    case MSSIPOTF_E_FILE_CHECKSUM                                                 : return "The file checksum is incorrect";
    case MSSIPOTF_E_FAILED_POLICY                                                 : return "The signature does not have the correct attributes for the policy";
    case MSSIPOTF_E_FAILED_HINTS_CHECK                                            : return "The file did not pass the hints check";
    case MSSIPOTF_E_NOT_OPENTYPE                                                  : return "The file is not an OpenType file";
    case MSSIPOTF_E_FILE                                                          : return "Failed on a file operation (open, map, read, write)";
    case MSSIPOTF_E_CRYPT                                                         : return "A call to a CryptoAPI function failed";
    case MSSIPOTF_E_BADVERSION                                                    : return "There is a bad version number in the file";
    case MSSIPOTF_E_DSIG_STRUCTURE                                                : return "The structure of the DSIG table is incorrect";
    case MSSIPOTF_E_PCONST_CHECK                                                  : return "A check failed in a partially constant table";
    case MSSIPOTF_E_STRUCTURE                                                     : return "Some kind of structural error";
    case ERROR_CRED_REQUIRES_CONFIRMATION                                         : return "The requested credential requires confirmation";
    case TRUST_E_PROVIDER_UNKNOWN                                                 : return "Unknown trust provider";
    case TRUST_E_ACTION_UNKNOWN                                                   : return "The trust verification action specified is not supported by the specified trust provider";
    case TRUST_E_SUBJECT_FORM_UNKNOWN                                             : return "The form specified for the subject is not one supported or known by the specified trust provider";
    case TRUST_E_SUBJECT_NOT_TRUSTED                                              : return "The subject is not trusted for the specified action";
    case DIGSIG_E_ENCODE                                                          : return "Error due to problem in ASN.1 encoding process";
    case DIGSIG_E_DECODE                                                          : return "Error due to problem in ASN.1 decoding process";
    case DIGSIG_E_EXTENSIBILITY                                                   : return "Reading / writing Extensions where Attributes are appropriate, and vice versa";
    case DIGSIG_E_CRYPTO                                                          : return "Unspecified cryptographic failure";
    case PERSIST_E_SIZEDEFINITE                                                   : return "The size of the data could not be determined";
    case PERSIST_E_SIZEINDEFINITE                                                 : return "The size of the indefinite-sized data could not be determined";
    case PERSIST_E_NOTSELFSIZING                                                  : return "This object does not read and write self-sizing data";
    case TRUST_E_NOSIGNATURE                                                      : return "No signature was present in the subject";
    case CERT_E_EXPIRED                                                           : return "A required certificate is not within its validity period when verifying against the current system clock or the timestamp in the signed file";
    case CERT_E_VALIDITYPERIODNESTING                                             : return "The validity periods of the certification chain do not nest correctly";
    case CERT_E_ROLE                                                              : return "A certificate that can only be used as an end-entity is being used as a CA or vice versa";
    case CERT_E_PATHLENCONST                                                      : return "A path length constraint in the certification chain has been violated";
    case CERT_E_CRITICAL                                                          : return "A certificate contains an unknown extension that is marked 'critical'";
    case CERT_E_PURPOSE                                                           : return "A certificate being used for a purpose other than the ones specified by its CA";
    case CERT_E_ISSUERCHAINING                                                    : return "A parent of a given certificate in fact did not issue that child certificate";
    case CERT_E_MALFORMED                                                         : return "A certificate is missing or has an empty value for an important field, such as a subject or issuer name";
    case CERT_E_UNTRUSTEDROOT                                                     : return "A certificate chain processed, but terminated in a root certificate which is not trusted by the trust provider";
    case CERT_E_CHAINING                                                          : return "A certificate chain could not be built to a trusted root authority";
    case TRUST_E_FAIL                                                             : return "Generic trust failure";
    case CERT_E_REVOKED                                                           : return "A certificate was explicitly revoked by its issuer";
    case CERT_E_UNTRUSTEDTESTROOT                                                 : return "The certification path terminates with the test root which is not trusted with the current policy settings";
    case CERT_E_REVOCATION_FAILURE                                                : return "The revocation process could not continue - the certificate(s) could not be checked";
    case CERT_E_CN_NO_MATCH                                                       : return "The certificate's CN name does not match the passed value";
    case CERT_E_WRONG_USAGE                                                       : return "The certificate is not valid for the requested usage";
    case TRUST_E_EXPLICIT_DISTRUST                                                : return "The certificate was explicitly marked as untrusted by the user";
    case CERT_E_UNTRUSTEDCA                                                       : return "A certification chain processed correctly, but one of the CA certificates is not trusted by the policy provider";
    case CERT_E_INVALID_POLICY                                                    : return "The certificate has invalid policy";
    case CERT_E_INVALID_NAME                                                      : return "The certificate has an invalid name. The name is not included in the permitted list or is explicitly excluded";
    case SPAPI_E_EXPECTED_SECTION_NAME                                            : return "A non-empty line was encountered in the INF before the start of a section";
    case SPAPI_E_BAD_SECTION_NAME_LINE                                            : return "A section name marker in the INF is not complete, or does not exist on a line by itself";
    case SPAPI_E_SECTION_NAME_TOO_LONG                                            : return "An INF section was encountered whose name exceeds the maximum section name length";
    case SPAPI_E_GENERAL_SYNTAX                                                   : return "The syntax of the INF is invalid";
    case SPAPI_E_WRONG_INF_STYLE                                                  : return "The style of the INF is different than what was requested";
    case SPAPI_E_SECTION_NOT_FOUND                                                : return "The required section was not found in the INF";
    case SPAPI_E_LINE_NOT_FOUND                                                   : return "The required line was not found in the INF";
    case SPAPI_E_NO_BACKUP                                                        : return "The files affected by the installation of this file queue have not been backed up for uninstall";
    case SPAPI_E_NO_ASSOCIATED_CLASS                                              : return "The INF or the device information set or element does not have an associated install class";
    case SPAPI_E_CLASS_MISMATCH                                                   : return "The INF or the device information set or element does not match the specified install class";
    case SPAPI_E_DUPLICATE_FOUND                                                  : return "An existing device was found that is a duplicate of the device being manually installed";
    case SPAPI_E_NO_DRIVER_SELECTED                                               : return "There is no driver selected for the device information set or element";
    case SPAPI_E_KEY_DOES_NOT_EXIST                                               : return "The requested device registry key does not exist";
    case SPAPI_E_INVALID_DEVINST_NAME                                             : return "The device instance name is invalid";
    case SPAPI_E_INVALID_CLASS                                                    : return "The install class is not present or is invalid";
    case SPAPI_E_DEVINST_ALREADY_EXISTS                                           : return "The device instance cannot be created because it already exists";
    case SPAPI_E_DEVINFO_NOT_REGISTERED                                           : return "The operation cannot be performed on a device information element that has not been registered";
    case SPAPI_E_INVALID_REG_PROPERTY                                             : return "The device property code is invalid";
    case SPAPI_E_NO_INF                                                           : return "The INF from which a driver list is to be built does not exist";
    case SPAPI_E_NO_SUCH_DEVINST                                                  : return "The device instance does not exist in the hardware tree";
    case SPAPI_E_CANT_LOAD_CLASS_ICON                                             : return "The icon representing this install class cannot be loaded";
    case SPAPI_E_INVALID_CLASS_INSTALLER                                          : return "The class installer registry entry is invalid";
    case SPAPI_E_DI_DO_DEFAULT                                                    : return "The class installer has indicated that the default action should be performed for this installation request";
    case SPAPI_E_DI_NOFILECOPY                                                    : return "The operation does not require any files to be copied";
    case SPAPI_E_INVALID_HWPROFILE                                                : return "The specified hardware profile does not exist";
    case SPAPI_E_NO_DEVICE_SELECTED                                               : return "There is no device information element currently selected for this device information set";
    case SPAPI_E_DEVINFO_LIST_LOCKED                                              : return "The operation cannot be performed because the device information set is locked";
    case SPAPI_E_DEVINFO_DATA_LOCKED                                              : return "The operation cannot be performed because the device information element is locked";
    case SPAPI_E_DI_BAD_PATH                                                      : return "The specified path does not contain any applicable device INFs";
    case SPAPI_E_NO_CLASSINSTALL_PARAMS                                           : return "No class installer parameters have been set for the device information set or element";
    case SPAPI_E_FILEQUEUE_LOCKED                                                 : return "The operation cannot be performed because the file queue is locked";
    case SPAPI_E_BAD_SERVICE_INSTALLSECT                                          : return "A service installation section in this INF is invalid";
    case SPAPI_E_NO_CLASS_DRIVER_LIST                                             : return "There is no class driver list for the device information element";
    case SPAPI_E_NO_ASSOCIATED_SERVICE                                            : return "The installation failed because a function driver was not specified for this device instance";
    case SPAPI_E_NO_DEFAULT_DEVICE_INTERFACE                                      : return "There is presently no default device interface designated for this interface class";
    case SPAPI_E_DEVICE_INTERFACE_ACTIVE                                          : return "The operation cannot be performed because the device interface is currently active";
    case SPAPI_E_DEVICE_INTERFACE_REMOVED                                         : return "The operation cannot be performed because the device interface has been removed from the system";
    case SPAPI_E_BAD_INTERFACE_INSTALLSECT                                        : return "An interface installation section in this INF is invalid";
    case SPAPI_E_NO_SUCH_INTERFACE_CLASS                                          : return "This interface class does not exist in the system";
    case SPAPI_E_INVALID_REFERENCE_STRING                                         : return "The reference string supplied for this interface device is invalid";
    case SPAPI_E_INVALID_MACHINENAME                                              : return "The specified machine name does not conform to UNC naming conventions";
    case SPAPI_E_REMOTE_COMM_FAILURE                                              : return "A general remote communication error occurred";
    case SPAPI_E_MACHINE_UNAVAILABLE                                              : return "The machine selected for remote communication is not available at this time";
    case SPAPI_E_NO_CONFIGMGR_SERVICES                                            : return "The Plug and Play service is not available on the remote machine";
    case SPAPI_E_INVALID_PROPPAGE_PROVIDER                                        : return "The property page provider registry entry is invalid";
    case SPAPI_E_NO_SUCH_DEVICE_INTERFACE                                         : return "The requested device interface is not present in the system";
    case SPAPI_E_DI_POSTPROCESSING_REQUIRED                                       : return "The device's co-installer has additional work to perform after installation is complete";
    case SPAPI_E_INVALID_COINSTALLER                                              : return "The device's co-installer is invalid";
    case SPAPI_E_NO_COMPAT_DRIVERS                                                : return "There are no compatible drivers for this device";
    case SPAPI_E_NO_DEVICE_ICON                                                   : return "There is no icon that represents this device or device type";
    case SPAPI_E_INVALID_INF_LOGCONFIG                                            : return "A logical configuration specified in this INF is invalid";
    case SPAPI_E_DI_DONT_INSTALL                                                  : return "The class installer has denied the request to install or upgrade this device";
    case SPAPI_E_INVALID_FILTER_DRIVER                                            : return "One of the filter drivers installed for this device is invalid";
    case SPAPI_E_NON_WINDOWS_NT_DRIVER                                            : return "The driver selected for this device does not support this version of Windows";
    case SPAPI_E_NON_WINDOWS_DRIVER                                               : return "The driver selected for this device does not support Windows";
    case SPAPI_E_NO_CATALOG_FOR_OEM_INF                                           : return "The third-party INF does not contain digital signature information";
    case SPAPI_E_DEVINSTALL_QUEUE_NONNATIVE                                       : return "An invalid attempt was made to use a device installation file queue for verification of digital signatures relative to other platforms";
    case SPAPI_E_NOT_DISABLEABLE                                                  : return "The device cannot be disabled";
    case SPAPI_E_CANT_REMOVE_DEVINST                                              : return "The device could not be dynamically removed";
    case SPAPI_E_INVALID_TARGET                                                   : return "Cannot copy to specified target";
    case SPAPI_E_DRIVER_NONNATIVE                                                 : return "Driver is not intended for this platform";
    case SPAPI_E_IN_WOW64                                                         : return "Operation not allowed in WOW64";
    case SPAPI_E_SET_SYSTEM_RESTORE_POINT                                         : return "The operation involving unsigned file copying was rolled back, so that a system restore point could be set";
    case SPAPI_E_INCORRECTLY_COPIED_INF                                           : return "An INF was copied into the Windows INF directory in an improper manner";
    case SPAPI_E_SCE_DISABLED                                                     : return "The Security Configuration Editor (SCE) APIs have been disabled on this Embedded product";
    case SPAPI_E_UNKNOWN_EXCEPTION                                                : return "An unknown exception was encountered";
    case SPAPI_E_PNP_REGISTRY_ERROR                                               : return "A problem was encountered when accessing the Plug and Play registry database";
    case SPAPI_E_REMOTE_REQUEST_UNSUPPORTED                                       : return "The requested operation is not supported for a remote machine";
    case SPAPI_E_NOT_AN_INSTALLED_OEM_INF                                         : return "The specified file is not an installed OEM INF";
    case SPAPI_E_INF_IN_USE_BY_DEVICES                                            : return "One or more devices are presently installed using the specified INF";
    case SPAPI_E_DI_FUNCTION_OBSOLETE                                             : return "The requested device install operation is obsolete";
    case SPAPI_E_NO_AUTHENTICODE_CATALOG                                          : return "A file could not be verified because it does not have an associated catalog signed via Authenticode(tm)";
    case SPAPI_E_AUTHENTICODE_DISALLOWED                                          : return "Authenticode(tm) signature verification is not supported for the specified INF";
    case SPAPI_E_AUTHENTICODE_TRUSTED_PUBLISHER                                   : return "The INF was signed with an Authenticode(tm) catalog from a trusted publisher";
    case SPAPI_E_AUTHENTICODE_TRUST_NOT_ESTABLISHED                               : return "The publisher of an Authenticode(tm) signed catalog has not yet been established as trusted";
    case SPAPI_E_AUTHENTICODE_PUBLISHER_NOT_TRUSTED                               : return "The publisher of an Authenticode(tm) signed catalog was not established as trusted";
    case SPAPI_E_SIGNATURE_OSATTRIBUTE_MISMATCH                                   : return "The software was tested for compliance with Windows Logo requirements on a different version of Windows, and may not be compatible with this version";
    case SPAPI_E_ONLY_VALIDATE_VIA_AUTHENTICODE                                   : return "The file may only be validated by a catalog signed via Authenticode(tm)";
    case SPAPI_E_DEVICE_INSTALLER_NOT_READY                                       : return "One of the installers for this device cannot perform the installation at this time";
    case SPAPI_E_DRIVER_STORE_ADD_FAILED                                          : return "A problem was encountered while attempting to add the driver to the store";
    case SPAPI_E_DEVICE_INSTALL_BLOCKED                                           : return "The installation of this device is forbidden by system policy. Contact your system administrator";
    case SPAPI_E_DRIVER_INSTALL_BLOCKED                                           : return "The installation of this driver is forbidden by system policy. Contact your system administrator";
    case SPAPI_E_WRONG_INF_TYPE                                                   : return "The specified INF is the wrong type for this operation";
    case SPAPI_E_FILE_HASH_NOT_IN_CATALOG                                         : return "The hash for the file is not present in the specified catalog file. The file is likely corrupt or the victim of tampering";
    case SPAPI_E_DRIVER_STORE_DELETE_FAILED                                       : return "A problem was encountered while attempting to delete the driver from the store";
    case SPAPI_E_UNRECOVERABLE_STACK_OVERFLOW                                     : return "An unrecoverable stack overflow was encountered";
    case SPAPI_E_ERROR_NOT_INSTALLED                                              : return "No installed components were detected";
    case SCARD_F_INTERNAL_ERROR                                                   : return "An internal consistency check failed";
    case SCARD_E_CANCELLED                                                        : return "The action was cancelled by an SCardCancel request";
    case SCARD_E_INVALID_HANDLE                                                   : return "The supplied handle was invalid";
    case SCARD_E_INVALID_PARAMETER                                                : return "One or more of the supplied parameters could not be properly interpreted";
    case SCARD_E_INVALID_TARGET                                                   : return "Registry startup information is missing or invalid";
    case SCARD_E_NO_MEMORY                                                        : return "Not enough memory available to complete this command";
    case SCARD_F_WAITED_TOO_LONG                                                  : return "An internal consistency timer has expired";
    case SCARD_E_INSUFFICIENT_BUFFER                                              : return "The data buffer to receive returned data is too small for the returned data";
    case SCARD_E_UNKNOWN_READER                                                   : return "The specified reader name is not recognized";
    case SCARD_E_TIMEOUT                                                          : return "The user-specified timeout value has expired";
    case SCARD_E_SHARING_VIOLATION                                                : return "The smart card cannot be accessed because of other connections outstanding";
    case SCARD_E_NO_SMARTCARD                                                     : return "The operation requires a smart card, but no smart card is currently in the device";
    case SCARD_E_UNKNOWN_CARD                                                     : return "The specified smart card name is not recognized";
    case SCARD_E_CANT_DISPOSE                                                     : return "The system could not dispose of the media in the requested manner";
    case SCARD_E_PROTO_MISMATCH                                                   : return "The requested protocols are incompatible with the protocol currently in use with the smart card";
    case SCARD_E_NOT_READY                                                        : return "The reader or smart card is not ready to accept commands";
    case SCARD_E_INVALID_VALUE                                                    : return "One or more of the supplied parameters values could not be properly interpreted";
    case SCARD_E_SYSTEM_CANCELLED                                                 : return "The action was cancelled by the system, presumably to log off or shut down";
    case SCARD_F_COMM_ERROR                                                       : return "An internal communications error has been detected";
    case SCARD_F_UNKNOWN_ERROR                                                    : return "An internal error has been detected, but the source is unknown";
    case SCARD_E_INVALID_ATR                                                      : return "An ATR obtained from the registry is not a valid ATR string";
    case SCARD_E_NOT_TRANSACTED                                                   : return "An attempt was made to end a non-existent transaction";
    case SCARD_E_READER_UNAVAILABLE                                               : return "The specified reader is not currently available for use";
    case SCARD_P_SHUTDOWN                                                         : return "The operation has been aborted to allow the server application to exit";
    case SCARD_E_PCI_TOO_SMALL                                                    : return "The PCI Receive buffer was too small";
    case SCARD_E_READER_UNSUPPORTED                                               : return "The reader driver does not meet minimal requirements for support";
    case SCARD_E_DUPLICATE_READER                                                 : return "The reader driver did not produce a unique reader name";
    case SCARD_E_CARD_UNSUPPORTED                                                 : return "The smart card does not meet minimal requirements for support";
    case SCARD_E_NO_SERVICE                                                       : return "The Smart Card Resource Manager is not running";
    case SCARD_E_SERVICE_STOPPED                                                  : return "The Smart Card Resource Manager has shut down";
    case SCARD_E_UNEXPECTED                                                       : return "An unexpected card error has occurred";
    case SCARD_E_ICC_INSTALLATION                                                 : return "No Primary Provider can be found for the smart card";
    case SCARD_E_ICC_CREATEORDER                                                  : return "The requested order of object creation is not supported";
    case SCARD_E_UNSUPPORTED_FEATURE                                              : return "This smart card does not support the requested feature";
    case SCARD_E_DIR_NOT_FOUND                                                    : return "The identified directory does not exist in the smart card";
    case SCARD_E_FILE_NOT_FOUND                                                   : return "The identified file does not exist in the smart card";
    case SCARD_E_NO_DIR                                                           : return "The supplied path does not represent a smart card directory";
    case SCARD_E_NO_FILE                                                          : return "The supplied path does not represent a smart card file";
    case SCARD_E_NO_ACCESS                                                        : return "Access is denied to this file";
    case SCARD_E_WRITE_TOO_MANY                                                   : return "The smart card does not have enough memory to store the information";
    case SCARD_E_BAD_SEEK                                                         : return "There was an error trying to set the smart card file object pointer";
    case SCARD_E_INVALID_CHV                                                      : return "The supplied PIN is incorrect";
    case SCARD_E_UNKNOWN_RES_MNG                                                  : return "An unrecognized error code was returned from a layered component";
    case SCARD_E_NO_SUCH_CERTIFICATE                                              : return "The requested certificate does not exist";
    case SCARD_E_CERTIFICATE_UNAVAILABLE                                          : return "The requested certificate could not be obtained";
    case SCARD_E_NO_READERS_AVAILABLE                                             : return "Cannot find a smart card reader";
    case SCARD_E_COMM_DATA_LOST                                                   : return "A communications error with the smart card has been detected. Retry the operation";
    case SCARD_E_NO_KEY_CONTAINER                                                 : return "The requested key container does not exist on the smart card";
    case SCARD_E_SERVER_TOO_BUSY                                                  : return "The Smart Card Resource Manager is too busy to complete this operation";
    case SCARD_E_PIN_CACHE_EXPIRED                                                : return "The smart card PIN cache has expired";
    case SCARD_E_NO_PIN_CACHE                                                     : return "The smart card PIN cannot be cached";
    case SCARD_E_READ_ONLY_CARD                                                   : return "The smart card is read only and cannot be written to";
    case SCARD_W_UNSUPPORTED_CARD                                                 : return "The reader cannot communicate with the smart card, due to ATR configuration conflicts";
    case SCARD_W_UNRESPONSIVE_CARD                                                : return "The smart card is not responding to a reset";
    case SCARD_W_UNPOWERED_CARD                                                   : return "Power has been removed from the smart card, so that further communication is not possible";
    case SCARD_W_RESET_CARD                                                       : return "The smart card has been reset, so any shared state information is invalid";
    case SCARD_W_REMOVED_CARD                                                     : return "The smart card has been removed, so that further communication is not possible";
    case SCARD_W_SECURITY_VIOLATION                                               : return "Access was denied because of a security violation";
    case SCARD_W_WRONG_CHV                                                        : return "The card cannot be accessed because the wrong PIN was presented";
    case SCARD_W_CHV_BLOCKED                                                      : return "The card cannot be accessed because the maximum number of PIN entry attempts has been reached";
    case SCARD_W_EOF                                                              : return "The end of the smart card file has been reached";
    case SCARD_W_CANCELLED_BY_USER                                                : return "The action was cancelled by the user";
    case SCARD_W_CARD_NOT_AUTHENTICATED                                           : return "No PIN was presented to the smart card";
    case SCARD_W_CACHE_ITEM_NOT_FOUND                                             : return "The requested item could not be found in the cache";
    case SCARD_W_CACHE_ITEM_STALE                                                 : return "The requested cache item is too old and was deleted from the cache";
    case SCARD_W_CACHE_ITEM_TOO_BIG                                               : return "The new cache item exceeds the maximum per-item size defined for the cache";
    case COMADMIN_E_OBJECTERRORS                                                  : return "Errors occurred accessing one or more objects - the ErrorInfo collection may have more detail";
    case COMADMIN_E_OBJECTINVALID                                                 : return "One or more of the object's properties are missing or invalid";
    case COMADMIN_E_KEYMISSING                                                    : return "The object was not found in the catalog";
    case COMADMIN_E_ALREADYINSTALLED                                              : return "The object is already registered";
    case COMADMIN_E_APP_FILE_WRITEFAIL                                            : return "Error occurred writing to the application file";
    case COMADMIN_E_APP_FILE_READFAIL                                             : return "Error occurred reading the application file";
    case COMADMIN_E_APP_FILE_VERSION                                              : return "Invalid version number in application file";
    case COMADMIN_E_BADPATH                                                       : return "The file path is invalid";
    case COMADMIN_E_APPLICATIONEXISTS                                             : return "The application is already installed";
    case COMADMIN_E_ROLEEXISTS                                                    : return "The role already exists";
    case COMADMIN_E_CANTCOPYFILE                                                  : return "An error occurred copying the file";
    case COMADMIN_E_NOUSER                                                        : return "One or more users are not valid";
    case COMADMIN_E_INVALIDUSERIDS                                                : return "One or more users in the application file are not valid";
    case COMADMIN_E_NOREGISTRYCLSID                                               : return "The component's CLSID is missing or corrupt";
    case COMADMIN_E_BADREGISTRYPROGID                                             : return "The component's progID is missing or corrupt";
    case COMADMIN_E_AUTHENTICATIONLEVEL                                           : return "Unable to set required authentication level for update request";
    case COMADMIN_E_USERPASSWDNOTVALID                                            : return "The identity or password set on the application is not valid";
    case COMADMIN_E_CLSIDORIIDMISMATCH                                            : return "Application file CLSIDs or IIDs do not match corresponding DLLs";
    case COMADMIN_E_REMOTEINTERFACE                                               : return "Interface information is either missing or changed";
    case COMADMIN_E_DLLREGISTERSERVER                                             : return "DllRegisterServer failed on component install";
    case COMADMIN_E_NOSERVERSHARE                                                 : return "No server file share available";
    case COMADMIN_E_DLLLOADFAILED                                                 : return "DLL could not be loaded";
    case COMADMIN_E_BADREGISTRYLIBID                                              : return "The registered TypeLib ID is not valid";
    case COMADMIN_E_APPDIRNOTFOUND                                                : return "Application install directory not found";
    case COMADMIN_E_REGISTRARFAILED                                               : return "Errors occurred while in the component registrar";
    case COMADMIN_E_COMPFILE_DOESNOTEXIST                                         : return "The file does not exist";
    case COMADMIN_E_COMPFILE_LOADDLLFAIL                                          : return "The DLL could not be loaded";
    case COMADMIN_E_COMPFILE_GETCLASSOBJ                                          : return "GetClassObject failed in the DLL";
    case COMADMIN_E_COMPFILE_CLASSNOTAVAIL                                        : return "The DLL does not support the components listed in the TypeLib";
    case COMADMIN_E_COMPFILE_BADTLB                                               : return "The TypeLib could not be loaded";
    case COMADMIN_E_COMPFILE_NOTINSTALLABLE                                       : return "The file does not contain components or component information";
    case COMADMIN_E_NOTCHANGEABLE                                                 : return "Changes to this object and its sub-objects have been disabled";
    case COMADMIN_E_NOTDELETEABLE                                                 : return "The delete function has been disabled for this object";
    case COMADMIN_E_SESSION                                                       : return "The server catalog version is not supported";
    case COMADMIN_E_COMP_MOVE_LOCKED                                              : return "The component move was disallowed, because the source or destination application is either a system application or currently locked against changes";
    case COMADMIN_E_COMP_MOVE_BAD_DEST                                            : return "The component move failed because the destination application no longer exists";
    case COMADMIN_E_REGISTERTLB                                                   : return "The system was unable to register the TypeLib";
    case COMADMIN_E_SYSTEMAPP                                                     : return "This operation cannot be performed on the system application";
    case COMADMIN_E_COMPFILE_NOREGISTRAR                                          : return "The component registrar referenced in this file is not available";
    case COMADMIN_E_COREQCOMPINSTALLED                                            : return "A component in the same DLL is already installed";
    case COMADMIN_E_SERVICENOTINSTALLED                                           : return "The service is not installed";
    case COMADMIN_E_PROPERTYSAVEFAILED                                            : return "One or more property settings are either invalid or in conflict with each other";
    case COMADMIN_E_OBJECTEXISTS                                                  : return "The object you are attempting to add or rename already exists";
    case COMADMIN_E_COMPONENTEXISTS                                               : return "The component already exists";
    case COMADMIN_E_REGFILE_CORRUPT                                               : return "The registration file is corrupt";
    case COMADMIN_E_PROPERTY_OVERFLOW                                             : return "The property value is too large";
    case COMADMIN_E_NOTINREGISTRY                                                 : return "Object was not found in registry";
    case COMADMIN_E_OBJECTNOTPOOLABLE                                             : return "This object is not poolable";
    case COMADMIN_E_APPLID_MATCHES_CLSID                                          : return "A CLSID with the same GUID as the new application ID is already installed on this machine";
    case COMADMIN_E_ROLE_DOES_NOT_EXIST                                           : return "A role assigned to a component, interface, or method did not exist in the application";
    case COMADMIN_E_START_APP_NEEDS_COMPONENTS                                    : return "You must have components in an application in order to start the application";
    case COMADMIN_E_REQUIRES_DIFFERENT_PLATFORM                                   : return "This operation is not enabled on this platform";
    case COMADMIN_E_CAN_NOT_EXPORT_APP_PROXY                                      : return "Application Proxy is not exportable";
    case COMADMIN_E_CAN_NOT_START_APP                                             : return "Failed to start application because it is either a library application or an application proxy";
    case COMADMIN_E_CAN_NOT_EXPORT_SYS_APP                                        : return "System application is not exportable";
    case COMADMIN_E_CANT_SUBSCRIBE_TO_COMPONENT                                   : return "Cannot subscribe to this component (the component may have been imported)";
    case COMADMIN_E_EVENTCLASS_CANT_BE_SUBSCRIBER                                 : return "An event class cannot also be a subscriber component";
    case COMADMIN_E_LIB_APP_PROXY_INCOMPATIBLE                                    : return "Library applications and application proxies are incompatible";
    case COMADMIN_E_BASE_PARTITION_ONLY                                           : return "This function is valid for the base partition only";
    case COMADMIN_E_START_APP_DISABLED                                            : return "You cannot start an application that has been disabled";
    case COMADMIN_E_CAT_DUPLICATE_PARTITION_NAME                                  : return "The specified partition name is already in use on this computer";
    case COMADMIN_E_CAT_INVALID_PARTITION_NAME                                    : return "The specified partition name is invalid. Check that the name contains at least one visible character";
    case COMADMIN_E_CAT_PARTITION_IN_USE                                          : return "The partition cannot be deleted because it is the default partition for one or more users";
    case COMADMIN_E_FILE_PARTITION_DUPLICATE_FILES                                : return "The partition cannot be exported, because one or more components in the partition have the same file name";
    case COMADMIN_E_CAT_IMPORTED_COMPONENTS_NOT_ALLOWED                           : return "Applications that contain one or more imported components cannot be installed into a non-base partition";
    case COMADMIN_E_AMBIGUOUS_APPLICATION_NAME                                    : return "The application name is not unique and cannot be resolved to an application id";
    case COMADMIN_E_AMBIGUOUS_PARTITION_NAME                                      : return "The partition name is not unique and cannot be resolved to a partition id";
    case COMADMIN_E_REGDB_NOTINITIALIZED                                          : return "The COM+ registry database has not been initialized";
    case COMADMIN_E_REGDB_NOTOPEN                                                 : return "The COM+ registry database is not open";
    case COMADMIN_E_REGDB_SYSTEMERR                                               : return "The COM+ registry database detected a system error";
    case COMADMIN_E_REGDB_ALREADYRUNNING                                          : return "The COM+ registry database is already running";
    case COMADMIN_E_MIG_VERSIONNOTSUPPORTED                                       : return "This version of the COM+ registry database cannot be migrated";
    case COMADMIN_E_MIG_SCHEMANOTFOUND                                            : return "The schema version to be migrated could not be found in the COM+ registry database";
    case COMADMIN_E_CAT_BITNESSMISMATCH                                           : return "There was a type mismatch between binaries";
    case COMADMIN_E_CAT_UNACCEPTABLEBITNESS                                       : return "A binary of unknown or invalid type was provided";
    case COMADMIN_E_CAT_WRONGAPPBITNESS                                           : return "There was a type mismatch between a binary and an application";
    case COMADMIN_E_CAT_PAUSE_RESUME_NOT_SUPPORTED                                : return "The application cannot be paused or resumed";
    case COMADMIN_E_CAT_SERVERFAULT                                               : return "The COM+ Catalog Server threw an exception during execution";
    case COMQC_E_APPLICATION_NOT_QUEUED                                           : return "Only COM+ Applications marked \"queued\" can be invoked using the \"queue\" moniker";
    case COMQC_E_NO_QUEUEABLE_INTERFACES                                          : return "At least one interface must be marked \"queued\" in order to create a queued component instance with the \"queue\" moniker";
    case COMQC_E_QUEUING_SERVICE_NOT_AVAILABLE                                    : return "MSMQ is required for the requested operation and is not installed";
    case COMQC_E_NO_IPERSISTSTREAM                                                : return "Unable to marshal an interface that does not support IPersistStream";
    case COMQC_E_BAD_MESSAGE                                                      : return "The message is improperly formatted or was damaged in transit";
    case COMQC_E_UNAUTHENTICATED                                                  : return "An unauthenticated message was received by an application that accepts only authenticated messages";
    case COMQC_E_UNTRUSTED_ENQUEUER                                               : return "The message was requeued or moved by a user not in the \"QC Trusted User\" role";
    case MSDTC_E_DUPLICATE_RESOURCE                                               : return "Cannot create a duplicate resource of type Distributed Transaction Coordinator";
    case COMADMIN_E_OBJECT_PARENT_MISSING                                         : return "One of the objects being inserted or updated does not belong to a valid parent collection";
    case COMADMIN_E_OBJECT_DOES_NOT_EXIST                                         : return "One of the specified objects cannot be found";
    case COMADMIN_E_APP_NOT_RUNNING                                               : return "The specified application is not currently running";
    case COMADMIN_E_INVALID_PARTITION                                             : return "The partition(s) specified are not valid";
    case COMADMIN_E_SVCAPP_NOT_POOLABLE_OR_RECYCLABLE                             : return "COM+ applications that run as NT service may not be pooled or recycled";
    case COMADMIN_E_USER_IN_SET                                                   : return "One or more users are already assigned to a local partition set";
    case COMADMIN_E_CANTRECYCLELIBRARYAPPS                                        : return "Library applications may not be recycled";
    case COMADMIN_E_CANTRECYCLESERVICEAPPS                                        : return "Applications running as NT services may not be recycled";
    case COMADMIN_E_PROCESSALREADYRECYCLED                                        : return "The process has already been recycled";
    case COMADMIN_E_PAUSEDPROCESSMAYNOTBERECYCLED                                 : return "A paused process may not be recycled";
    case COMADMIN_E_CANTMAKEINPROCSERVICE                                         : return "Library applications may not be NT services";
    case COMADMIN_E_PROGIDINUSEBYCLSID                                            : return "The ProgID provided to the copy operation is invalid. The ProgID is in use by another registered CLSID";
    case COMADMIN_E_DEFAULT_PARTITION_NOT_IN_SET                                  : return "The partition specified as default is not a member of the partition set";
    case COMADMIN_E_RECYCLEDPROCESSMAYNOTBEPAUSED                                 : return "A recycled process may not be paused";
    case COMADMIN_E_PARTITION_ACCESSDENIED                                        : return "Access to the specified partition is denied";
    case COMADMIN_E_PARTITION_MSI_ONLY                                            : return "Only Application Files (*.MSI files) can be installed into partitions";
    case COMADMIN_E_LEGACYCOMPS_NOT_ALLOWED_IN_1_0_FORMAT                         : return "Applications containing one or more legacy components may not be exported to 1.0 format";
    case COMADMIN_E_LEGACYCOMPS_NOT_ALLOWED_IN_NONBASE_PARTITIONS                 : return "Legacy components may not exist in non-base partitions";
    case COMADMIN_E_COMP_MOVE_SOURCE                                              : return "A component cannot be moved (or copied) from the System Application, an application proxy or a non-changeable application";
    case COMADMIN_E_COMP_MOVE_DEST                                                : return "A component cannot be moved (or copied) to the System Application, an application proxy or a non-changeable application";
    case COMADMIN_E_COMP_MOVE_PRIVATE                                             : return "A private component cannot be moved (or copied) to a library application or to the base partition";
    case COMADMIN_E_BASEPARTITION_REQUIRED_IN_SET                                 : return "The Base Application Partition exists in all partition sets and cannot be removed";
    case COMADMIN_E_CANNOT_ALIAS_EVENTCLASS                                       : return "Alas, Event Class components cannot be aliased";
    case COMADMIN_E_PRIVATE_ACCESSDENIED                                          : return "Access is denied because the component is private";
    case COMADMIN_E_SAFERINVALID                                                  : return "The specified SAFER level is invalid";
    case COMADMIN_E_REGISTRY_ACCESSDENIED                                         : return "The specified user cannot write to the system registry";
    case COMADMIN_E_PARTITIONS_DISABLED                                           : return "COM+ partitions are currently disabled";
    case WER_S_REPORT_DEBUG                                                       : return "Debugger was attached";
    case WER_S_REPORT_UPLOADED                                                    : return "Report was uploaded";
    case WER_S_REPORT_QUEUED                                                      : return "Report was queued";
    case WER_S_DISABLED                                                           : return "Reporting was disabled";
    case WER_S_SUSPENDED_UPLOAD                                                   : return "Reporting was temporarily suspended";
    case WER_S_DISABLED_QUEUE                                                     : return "Report was not queued to queueing being disabled";
    case WER_S_DISABLED_ARCHIVE                                                   : return "Report was uploaded, but not archived due to archiving being disabled";
    case WER_S_REPORT_ASYNC                                                       : return "Reporting was successfully spun off as an asynchronous operation";
    case WER_S_IGNORE_ASSERT_INSTANCE                                             : return "The assertion was handled";
    case WER_S_IGNORE_ALL_ASSERTS                                                 : return "The assertion was handled and added to a permanent ignore list";
    case WER_S_ASSERT_CONTINUE                                                    : return "The assertion was resumed as unhandled";
    case WER_S_THROTTLED                                                          : return "Report was throttled";
    case WER_S_REPORT_UPLOADED_CAB                                                : return "Report was uploaded with cab";
    case WER_E_CRASH_FAILURE                                                      : return "Crash reporting failed";
    case WER_E_CANCELED                                                           : return "Report aborted due to user cancelation";
    case WER_E_NETWORK_FAILURE                                                    : return "Report aborted due to network failure";
    case WER_E_NOT_INITIALIZED                                                    : return "Report not initialized";
    case WER_E_ALREADY_REPORTING                                                  : return "Reporting is already in progress for the specified process";
    case WER_E_DUMP_THROTTLED                                                     : return "Dump not generated due to a throttle";
    case WER_E_INSUFFICIENT_CONSENT                                               : return "Operation failed due to insufficient user consent";
    case WER_E_TOO_HEAVY                                                          : return "Report aborted due to performance criteria";
    case ERROR_FLT_IO_COMPLETE                                                    : return "The IO was completed by a filter";
    case ERROR_FLT_NO_HANDLER_DEFINED                                             : return "A handler was not defined by the filter for this operation";
    case ERROR_FLT_CONTEXT_ALREADY_DEFINED                                        : return "A context is already defined for this object";
    case ERROR_FLT_INVALID_ASYNCHRONOUS_REQUEST                                   : return "Asynchronous requests are not valid for this operation";
    case ERROR_FLT_DISALLOW_FAST_IO                                               : return "Disallow the Fast IO path for this operation";
    case ERROR_FLT_INVALID_NAME_REQUEST                                           : return "An invalid name request was made. The name requested cannot be retrieved at this time";
    case ERROR_FLT_NOT_SAFE_TO_POST_OPERATION                                     : return "Posting this operation to a worker thread for further processing is not safe at this time because it could lead to a system deadlock";
    case ERROR_FLT_NOT_INITIALIZED                                                : return "The Filter Manager was not initialized when a filter tried to register. Make sure that the Filter Manager is getting loaded as a driver";
    case ERROR_FLT_FILTER_NOT_READY                                               : return "The filter is not ready for attachment to volumes because it has not finished initializing (FltStartFiltering has not been called)";
    case ERROR_FLT_POST_OPERATION_CLEANUP                                         : return "The filter must cleanup any operation specific context at this time because it is being removed from the system before the operation is completed by the lower drivers";
    case ERROR_FLT_INTERNAL_ERROR                                                 : return "The Filter Manager had an internal error from which it cannot recover, therefore the operation has been failed. This is usually the result of a filter returning an invalid value from a pre-operation callback";
    case ERROR_FLT_DELETING_OBJECT                                                : return "The object specified for this action is in the process of being deleted, therefore the action requested cannot be completed at this time";
    case ERROR_FLT_MUST_BE_NONPAGED_POOL                                          : return "Non-paged pool must be used for this type of context";
    case ERROR_FLT_DUPLICATE_ENTRY                                                : return "A duplicate handler definition has been provided for an operation";
    case ERROR_FLT_CBDQ_DISABLED                                                  : return "The callback data queue has been disabled";
    case ERROR_FLT_DO_NOT_ATTACH                                                  : return "Do not attach the filter to the volume at this time";
    case ERROR_FLT_DO_NOT_DETACH                                                  : return "Do not detach the filter from the volume at this time";
    case ERROR_FLT_INSTANCE_ALTITUDE_COLLISION                                    : return "An instance already exists at this altitude on the volume specified";
    case ERROR_FLT_INSTANCE_NAME_COLLISION                                        : return "An instance already exists with this name on the volume specified";
    case ERROR_FLT_FILTER_NOT_FOUND                                               : return "The system could not find the filter specified";
    case ERROR_FLT_VOLUME_NOT_FOUND                                               : return "The system could not find the volume specified";
    case ERROR_FLT_INSTANCE_NOT_FOUND                                             : return "The system could not find the instance specified";
    case ERROR_FLT_CONTEXT_ALLOCATION_NOT_FOUND                                   : return "No registered context allocation definition was found for the given request";
    case ERROR_FLT_INVALID_CONTEXT_REGISTRATION                                   : return "An invalid parameter was specified during context registration";
    case ERROR_FLT_NAME_CACHE_MISS                                                : return "The name requested was not found in Filter Manager's name cache and could not be retrieved from the file system";
    case ERROR_FLT_NO_DEVICE_OBJECT                                               : return "The requested device object does not exist for the given volume";
    case ERROR_FLT_VOLUME_ALREADY_MOUNTED                                         : return "The specified volume is already mounted";
    case ERROR_FLT_ALREADY_ENLISTED                                               : return "The specified Transaction Context is already enlisted in a transaction";
    case ERROR_FLT_CONTEXT_ALREADY_LINKED                                         : return "The specifiec context is already attached to another object";
    case ERROR_FLT_NO_WAITER_FOR_REPLY                                            : return "No waiter is present for the filter's reply to this message";
    case ERROR_FLT_REGISTRATION_BUSY                                              : return "The filesystem database resource is in use. Registration cannot complete at this time";
    case ERROR_HUNG_DISPLAY_DRIVER_THREAD                                         : return "The %%hs display driver has stopped working normally. Save your work and reboot the system to restore full display functionality";
    case DWM_E_COMPOSITIONDISABLED                                                : return "The operation could not be completed because desktop composition is disabled";
    case DWM_E_REMOTING_NOT_SUPPORTED                                             : return "The operation is not supported while running in a remote session";
    case DWM_E_NO_REDIRECTION_SURFACE_AVAILABLE                                   : return "The DWM was unable to provide a redireciton surface to complete the DirectX present";
    case DWM_E_NOT_QUEUING_PRESENTS                                               : return "The window specified is not currently using queued presents";
    case DWM_E_ADAPTER_NOT_FOUND                                                  : return "DWM can not find the adapter specified by the LUID";
    case DWM_S_GDI_REDIRECTION_SURFACE                                            : return "GDI redirection surface of the top level window was returned";
    case DWM_E_TEXTURE_TOO_LARGE                                                  : return "Redirection surface can not be created.  The size of the surface is larger than what is supported on this machine";
    case DWM_S_GDI_REDIRECTION_SURFACE_BLT_VIA_GDI                                : return "GDI redirection surface is either on a different adapter or in system memory. Perform blt via GDI";
    case ERROR_MONITOR_NO_DESCRIPTOR                                              : return "Monitor descriptor could not be obtained";
    case ERROR_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT                                  : return "Format of the obtained monitor descriptor is not supported by this release";
    case ERROR_MONITOR_INVALID_DESCRIPTOR_CHECKSUM                                : return "Checksum of the obtained monitor descriptor is invalid";
    case ERROR_MONITOR_INVALID_STANDARD_TIMING_BLOCK                              : return "Monitor descriptor contains an invalid standard timing block";
    case ERROR_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED                          : return "WMI data block registration failed for one of the MSMonitorClass WMI subclasses";
    case ERROR_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK                         : return "Provided monitor descriptor block is either corrupted or does not contain monitor's detailed serial number";
    case ERROR_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK                         : return "Provided monitor descriptor block is either corrupted or does not contain monitor's user friendly name";
    case ERROR_MONITOR_NO_MORE_DESCRIPTOR_DATA                                    : return "There is no monitor descriptor data at the specified (offset, size) region";
    case ERROR_MONITOR_INVALID_DETAILED_TIMING_BLOCK                              : return "Monitor descriptor contains an invalid detailed timing block";
    case ERROR_MONITOR_INVALID_MANUFACTURE_DATE                                   : return "Monitor descriptor contains invalid manufacture date";
    case ERROR_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER                                  : return "Exclusive mode ownership is needed to create unmanaged primary allocation";
    case ERROR_GRAPHICS_INSUFFICIENT_DMA_BUFFER                                   : return "The driver needs more DMA buffer space in order to complete the requested operation";
    case ERROR_GRAPHICS_INVALID_DISPLAY_ADAPTER                                   : return "Specified display adapter handle is invalid";
    case ERROR_GRAPHICS_ADAPTER_WAS_RESET                                         : return "Specified display adapter and all of its state has been reset";
    case ERROR_GRAPHICS_INVALID_DRIVER_MODEL                                      : return "The driver stack doesn't match the expected driver model";
    case ERROR_GRAPHICS_PRESENT_MODE_CHANGED                                      : return "Present happened but ended up into the changed desktop mode";
    case ERROR_GRAPHICS_PRESENT_OCCLUDED                                          : return "Nothing to present due to desktop occlusion";
    case ERROR_GRAPHICS_PRESENT_DENIED                                            : return "Not able to present due to denial of desktop access";
    case ERROR_GRAPHICS_CANNOTCOLORCONVERT                                        : return "Not able to present with color convertion";
    case ERROR_GRAPHICS_DRIVER_MISMATCH                                           : return "The kernel driver detected a version mismatch between it and the user mode driver";
    case ERROR_GRAPHICS_PARTIAL_DATA_POPULATED                                    : return "Specified buffer is not big enough to contain entire requested dataset. Partial data populated up to the size of the buffer. Caller needs to provide buffer of size as specified in the partially populated buffer's content (interface specific)";
    case ERROR_GRAPHICS_PRESENT_REDIRECTION_DISABLED                              : return "Present redirection is disabled (desktop windowing management subsystem is off)";
    case ERROR_GRAPHICS_PRESENT_UNOCCLUDED                                        : return "Previous exclusive VidPn source owner has released its ownership";
    case ERROR_GRAPHICS_WINDOWDC_NOT_AVAILABLE                                    : return "Window DC is not available for presentation";
    case ERROR_GRAPHICS_WINDOWLESS_PRESENT_DISABLED                               : return "Windowless present is disabled (desktop windowing management subsystem is off)";
    case ERROR_GRAPHICS_NO_VIDEO_MEMORY                                           : return "Not enough video memory available to complete the operation";
    case ERROR_GRAPHICS_CANT_LOCK_MEMORY                                          : return "Couldn't probe and lock the underlying memory of an allocation";
    case ERROR_GRAPHICS_ALLOCATION_BUSY                                           : return "The allocation is currently busy";
    case ERROR_GRAPHICS_TOO_MANY_REFERENCES                                       : return "An object being referenced has reach the maximum reference count already and can't be reference further";
    case ERROR_GRAPHICS_TRY_AGAIN_LATER                                           : return "A problem couldn't be solved due to some currently existing condition. The problem should be tried again later";
    case ERROR_GRAPHICS_TRY_AGAIN_NOW                                             : return "A problem couldn't be solved due to some currently existing condition. The problem should be tried again immediately";
    case ERROR_GRAPHICS_ALLOCATION_INVALID                                        : return "The allocation is invalid";
    case ERROR_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE                          : return "No more unswizzling aperture are currently available";
    case ERROR_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED                          : return "The current allocation can't be unswizzled by an aperture";
    case ERROR_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION                              : return "The request failed because a pinned allocation can't be evicted";
    case ERROR_GRAPHICS_INVALID_ALLOCATION_USAGE                                  : return "The allocation can't be used from its current segment location for the specified operation";
    case ERROR_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION                             : return "A locked allocation can't be used in the current command buffer";
    case ERROR_GRAPHICS_ALLOCATION_CLOSED                                         : return "The allocation being referenced has been closed permanently";
    case ERROR_GRAPHICS_INVALID_ALLOCATION_INSTANCE                               : return "An invalid allocation instance is being referenced";
    case ERROR_GRAPHICS_INVALID_ALLOCATION_HANDLE                                 : return "An invalid allocation handle is being referenced";
    case ERROR_GRAPHICS_WRONG_ALLOCATION_DEVICE                                   : return "The allocation being referenced doesn't belong to the current device";
    case ERROR_GRAPHICS_ALLOCATION_CONTENT_LOST                                   : return "The specified allocation lost its content";
    case ERROR_GRAPHICS_GPU_EXCEPTION_ON_DEVICE                                   : return "GPU exception is detected on the given device. The device is not able to be scheduled";
    case ERROR_GRAPHICS_SKIP_ALLOCATION_PREPARATION                               : return "Skip preparation of allocations referenced by the DMA buffer";
    case ERROR_GRAPHICS_INVALID_VIDPN_TOPOLOGY                                    : return "Specified VidPN topology is invalid";
    case ERROR_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED                              : return "Specified VidPN topology is valid but is not supported by this model of the display adapter";
    case ERROR_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED                    : return "Specified VidPN topology is valid but is not supported by the display adapter at this time, due to current allocation of its resources";
    case ERROR_GRAPHICS_INVALID_VIDPN                                             : return "Specified VidPN handle is invalid";
    case ERROR_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE                              : return "Specified video present source is invalid";
    case ERROR_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET                              : return "Specified video present target is invalid";
    case ERROR_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED                              : return "Specified VidPN modality is not supported (e.g. at least two of the pinned modes are not cofunctional)";
    case ERROR_GRAPHICS_MODE_NOT_PINNED                                           : return "No mode is pinned on the specified VidPN source/target";
    case ERROR_GRAPHICS_INVALID_VIDPN_SOURCEMODESET                               : return "Specified VidPN source mode set is invalid";
    case ERROR_GRAPHICS_INVALID_VIDPN_TARGETMODESET                               : return "Specified VidPN target mode set is invalid";
    case ERROR_GRAPHICS_INVALID_FREQUENCY                                         : return "Specified video signal frequency is invalid";
    case ERROR_GRAPHICS_INVALID_ACTIVE_REGION                                     : return "Specified video signal active region is invalid";
    case ERROR_GRAPHICS_INVALID_TOTAL_REGION                                      : return "Specified video signal total region is invalid";
    case ERROR_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE                         : return "Specified video present source mode is invalid";
    case ERROR_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE                         : return "Specified video present target mode is invalid";
    case ERROR_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET                            : return "Pinned mode must remain in the set on VidPN's cofunctional modality enumeration";
    case ERROR_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY                                  : return "Specified video present path is already in VidPN's topology";
    case ERROR_GRAPHICS_MODE_ALREADY_IN_MODESET                                   : return "Specified mode is already in the mode set";
    case ERROR_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET                             : return "Specified video present source set is invalid";
    case ERROR_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET                             : return "Specified video present target set is invalid";
    case ERROR_GRAPHICS_SOURCE_ALREADY_IN_SET                                     : return "Specified video present source is already in the video present source set";
    case ERROR_GRAPHICS_TARGET_ALREADY_IN_SET                                     : return "Specified video present target is already in the video present target set";
    case ERROR_GRAPHICS_INVALID_VIDPN_PRESENT_PATH                                : return "Specified VidPN present path is invalid";
    case ERROR_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY                             : return "Miniport has no recommendation for augmentation of the specified VidPN's topology";
    case ERROR_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET                         : return "Specified monitor frequency range set is invalid";
    case ERROR_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE                            : return "Specified monitor frequency range is invalid";
    case ERROR_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET                                 : return "Specified frequency range is not in the specified monitor frequency range set";
    case ERROR_GRAPHICS_NO_PREFERRED_MODE                                         : return "Specified mode set does not specify preference for one of its modes";
    case ERROR_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET                             : return "Specified frequency range is already in the specified monitor frequency range set";
    case ERROR_GRAPHICS_STALE_MODESET                                             : return "Specified mode set is stale. Please reacquire the new mode set";
    case ERROR_GRAPHICS_INVALID_MONITOR_SOURCEMODESET                             : return "Specified monitor source mode set is invalid";
    case ERROR_GRAPHICS_INVALID_MONITOR_SOURCE_MODE                               : return "Specified monitor source mode is invalid";
    case ERROR_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN                           : return "Miniport does not have any recommendation regarding the request to provide a functional VidPN given the current display adapter configuration";
    case ERROR_GRAPHICS_MODE_ID_MUST_BE_UNIQUE                                    : return "ID of the specified mode is already used by another mode in the set";
    case ERROR_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION           : return "System failed to determine a mode that is supported by both the display adapter and the monitor connected to it";
    case ERROR_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES                   : return "Number of video present targets must be greater than or equal to the number of video present sources";
    case ERROR_GRAPHICS_PATH_NOT_IN_TOPOLOGY                                      : return "Specified present path is not in VidPN's topology";
    case ERROR_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE                     : return "Display adapter must have at least one video present source";
    case ERROR_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET                     : return "Display adapter must have at least one video present target";
    case ERROR_GRAPHICS_INVALID_MONITORDESCRIPTORSET                              : return "Specified monitor descriptor set is invalid";
    case ERROR_GRAPHICS_INVALID_MONITORDESCRIPTOR                                 : return "Specified monitor descriptor is invalid";
    case ERROR_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET                              : return "Specified descriptor is not in the specified monitor descriptor set";
    case ERROR_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET                          : return "Specified descriptor is already in the specified monitor descriptor set";
    case ERROR_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE                       : return "ID of the specified monitor descriptor is already used by another descriptor in the set";
    case ERROR_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE                          : return "Specified video present target subset type is invalid";
    case ERROR_GRAPHICS_RESOURCES_NOT_RELATED                                     : return "Two or more of the specified resources are not related to each other, as defined by the interface semantics";
    case ERROR_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE                                  : return "ID of the specified video present source is already used by another source in the set";
    case ERROR_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE                                  : return "ID of the specified video present target is already used by another target in the set";
    case ERROR_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET                                 : return "Specified VidPN source cannot be used because there is no available VidPN target to connect it to";
    case ERROR_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER              : return "Newly arrived monitor could not be associated with a display adapter";
    case ERROR_GRAPHICS_NO_VIDPNMGR                                               : return "Display adapter in question does not have an associated VidPN manager";
    case ERROR_GRAPHICS_NO_ACTIVE_VIDPN                                           : return "VidPN manager of the display adapter in question does not have an active VidPN";
    case ERROR_GRAPHICS_STALE_VIDPN_TOPOLOGY                                      : return "Specified VidPN topology is stale. Please reacquire the new topology";
    case ERROR_GRAPHICS_MONITOR_NOT_CONNECTED                                     : return "There is no monitor connected on the specified video present target";
    case ERROR_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY                                    : return "Specified source is not part of the specified VidPN's topology";
    case ERROR_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE                               : return "Specified primary surface size is invalid";
    case ERROR_GRAPHICS_INVALID_VISIBLEREGION_SIZE                                : return "Specified visible region size is invalid";
    case ERROR_GRAPHICS_INVALID_STRIDE                                            : return "Specified stride is invalid";
    case ERROR_GRAPHICS_INVALID_PIXELFORMAT                                       : return "Specified pixel format is invalid";
    case ERROR_GRAPHICS_INVALID_COLORBASIS                                        : return "Specified color basis is invalid";
    case ERROR_GRAPHICS_INVALID_PIXELVALUEACCESSMODE                              : return "Specified pixel value access mode is invalid";
    case ERROR_GRAPHICS_TARGET_NOT_IN_TOPOLOGY                                    : return "Specified target is not part of the specified VidPN's topology";
    case ERROR_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT                        : return "Failed to acquire display mode management interface";
    case ERROR_GRAPHICS_VIDPN_SOURCE_IN_USE                                       : return "Specified VidPN source is already owned by a DMM client and cannot be used until that client releases it";
    case ERROR_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN                                  : return "Specified VidPN is active and cannot be accessed";
    case ERROR_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL                           : return "Specified VidPN present path importance ordinal is invalid";
    case ERROR_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION              : return "Specified VidPN present path content geometry transformation is invalid";
    case ERROR_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED        : return "Specified content geometry transformation is not supported on the respective VidPN present path";
    case ERROR_GRAPHICS_INVALID_GAMMA_RAMP                                        : return "Specified gamma ramp is invalid";
    case ERROR_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED                                  : return "Specified gamma ramp is not supported on the respective VidPN present path";
    case ERROR_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED                               : return "Multi-sampling is not supported on the respective VidPN present path";
    case ERROR_GRAPHICS_MODE_NOT_IN_MODESET                                       : return "Specified mode is not in the specified mode set";
    case ERROR_GRAPHICS_DATASET_IS_EMPTY                                          : return "Specified data set (e.g. mode set, frequency range set, descriptor set, topology, etc.) is empty";
    case ERROR_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET                               : return "Specified data set (e.g. mode set, frequency range set, descriptor set, topology, etc.) does not contain any more elements";
    case ERROR_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON              : return "Specified VidPN topology recommendation reason is invalid";
    case ERROR_GRAPHICS_INVALID_PATH_CONTENT_TYPE                                 : return "Specified VidPN present path content type is invalid";
    case ERROR_GRAPHICS_INVALID_COPYPROTECTION_TYPE                               : return "Specified VidPN present path copy protection type is invalid";
    case ERROR_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS                         : return "No more than one unassigned mode set can exist at any given time for a given VidPN source/target";
    case ERROR_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED           : return "Specified content transformation is not pinned on the specified VidPN present path";
    case ERROR_GRAPHICS_INVALID_SCANLINE_ORDERING                                 : return "Specified scanline ordering type is invalid";
    case ERROR_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED                              : return "Topology changes are not allowed for the specified VidPN";
    case ERROR_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS                          : return "All available importance ordinals are already used in specified topology";
    case ERROR_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT                               : return "Specified primary surface has a different private format attribute than the current primary surface";
    case ERROR_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM                            : return "Specified mode pruning algorithm is invalid";
    case ERROR_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN                         : return "Specified monitor capability origin is invalid";
    case ERROR_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT                 : return "Specified monitor frequency range constraint is invalid";
    case ERROR_GRAPHICS_MAX_NUM_PATHS_REACHED                                     : return "Maximum supported number of present paths has been reached";
    case ERROR_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION                        : return "Miniport requested that augmentation be cancelled for the specified source of the specified VidPN's topology";
    case ERROR_GRAPHICS_INVALID_CLIENT_TYPE                                       : return "Specified client type was not recognized";
    case ERROR_GRAPHICS_CLIENTVIDPN_NOT_SET                                       : return "Client VidPN is not set on this adapter (e.g. no user mode initiated mode changes took place on this adapter yet)";
    case ERROR_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED                         : return "Specified display adapter child device already has an external device connected to it";
    case ERROR_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED                            : return "Specified display adapter child device does not support descriptor exposure";
    case ERROR_GRAPHICS_UNKNOWN_CHILD_STATUS                                      : return "Child device presence was not reliably detected";
    case ERROR_GRAPHICS_NOT_A_LINKED_ADAPTER                                      : return "The display adapter is not linked to any other adapters";
    case ERROR_GRAPHICS_LEADLINK_NOT_ENUMERATED                                   : return "Lead adapter in a linked configuration was not enumerated yet";
    case ERROR_GRAPHICS_CHAINLINKS_NOT_ENUMERATED                                 : return "Some chain adapters in a linked configuration were not enumerated yet";
    case ERROR_GRAPHICS_ADAPTER_CHAIN_NOT_READY                                   : return "The chain of linked adapters is not ready to start because of an unknown failure";
    case ERROR_GRAPHICS_CHAINLINKS_NOT_STARTED                                    : return "An attempt was made to start a lead link display adapter when the chain links were not started yet";
    case ERROR_GRAPHICS_CHAINLINKS_NOT_POWERED_ON                                 : return "An attempt was made to power up a lead link display adapter when the chain links were powered down";
    case ERROR_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE                            : return "The adapter link was found to be in an inconsistent state. Not all adapters are in an expected PNP/Power state";
    case ERROR_GRAPHICS_LEADLINK_START_DEFERRED                                   : return "Starting the leadlink adapter has been deferred temporarily";
    case ERROR_GRAPHICS_NOT_POST_DEVICE_DRIVER                                    : return "The driver trying to start is not the same as the driver for the POSTed display adapter";
    case ERROR_GRAPHICS_POLLING_TOO_FREQUENTLY                                    : return "The display adapter is being polled for children too frequently at the same polling level";
    case ERROR_GRAPHICS_START_DEFERRED                                            : return "Starting the adapter has been deferred temporarily";
    case ERROR_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED                               : return "An operation is being attempted that requires the display adapter to be in a quiescent state";
    case ERROR_GRAPHICS_DEPENDABLE_CHILD_STATUS                                   : return "We can depend on the child device presence returned by the driver";
    case ERROR_GRAPHICS_OPM_NOT_SUPPORTED                                         : return "The driver does not support OPM";
    case ERROR_GRAPHICS_COPP_NOT_SUPPORTED                                        : return "The driver does not support COPP";
    case ERROR_GRAPHICS_UAB_NOT_SUPPORTED                                         : return "The driver does not support UAB";
    case ERROR_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS                          : return "The specified encrypted parameters are invalid";
    case ERROR_GRAPHICS_OPM_NO_VIDEO_OUTPUTS_EXIST                                : return "The GDI display device passed to this function does not have any active video outputs";
    case ERROR_GRAPHICS_OPM_INTERNAL_ERROR                                        : return "An internal error caused this operation to fail";
    case ERROR_GRAPHICS_OPM_INVALID_HANDLE                                        : return "The function failed because the caller passed in an invalid OPM user mode handle";
    case ERROR_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH                            : return "A certificate could not be returned because the certificate buffer passed to the function was too small";
    case ERROR_GRAPHICS_OPM_SPANNING_MODE_ENABLED                                 : return "A video output could not be created because the frame buffer is in spanning mode";
    case ERROR_GRAPHICS_OPM_THEATER_MODE_ENABLED                                  : return "A video output could not be created because the frame buffer is in theater mode";
    case ERROR_GRAPHICS_PVP_HFS_FAILED                                            : return "The function failed because the display adapter's Hardware Functionality Scan failed to validate the graphics hardware";
    case ERROR_GRAPHICS_OPM_INVALID_SRM                                           : return "The HDCP System Renewability Message passed to this function did not comply with section 5 of the HDCP 1.1 specification";
    case ERROR_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP                          : return "The video output cannot enable the High-bandwidth Digital Content Protection (HDCP) System because it does not support HDCP";
    case ERROR_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP                           : return "The video output cannot enable Analogue Copy Protection (ACP) because it does not support ACP";
    case ERROR_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA                         : return "The video output cannot enable the Content Generation Management System Analogue (CGMS-A) protection technology because it does not support CGMS-A";
    case ERROR_GRAPHICS_OPM_HDCP_SRM_NEVER_SET                                    : return "The IOPMVideoOutput::GetInformation method cannot return the version of the SRM being used because the application never successfully passed an SRM to the video output";
    case ERROR_GRAPHICS_OPM_RESOLUTION_TOO_HIGH                                   : return "The IOPMVideoOutput::Configure method cannot enable the specified output protection technology because the output's screen resolution is too high";
    case ERROR_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE                      : return "The IOPMVideoOutput::Configure method cannot enable HDCP because the display adapter's HDCP hardware is already being used by other physical outputs";
    case ERROR_GRAPHICS_OPM_VIDEO_OUTPUT_NO_LONGER_EXISTS                         : return "The operating system asynchronously destroyed this OPM video output because the operating system's state changed. This error typically occurs because the monitor PDO associated with this video output was removed, the monitor PDO associated with this video output was stopped, the video output's session became a non-console session or the video output's desktop became an inactive desktop";
    case ERROR_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS                       : return "The method failed because the session is changing its type. No IOPMVideoOutput methods can be called when a session is changing its type. There are currently three types of sessions: console, disconnected and remote";
    case ERROR_GRAPHICS_OPM_VIDEO_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS             : return "Either the IOPMVideoOutput::COPPCompatibleGetInformation, IOPMVideoOutput::GetInformation, or IOPMVideoOutput::Configure method failed. This error is returned when the caller tries to use a COPP specific command while the video output has OPM semantics only";
    case ERROR_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST                           : return "The IOPMVideoOutput::GetInformation and IOPMVideoOutput::COPPCompatibleGetInformation methods return this error if the passed in sequence number is not the expected sequence number or the passed in OMAC value is invalid";
    case ERROR_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR                                 : return "The method failed because an unexpected error occurred inside of a display driver";
    case ERROR_GRAPHICS_OPM_VIDEO_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS              : return "Either the IOPMVideoOutput::COPPCompatibleGetInformation, IOPMVideoOutput::GetInformation, or IOPMVideoOutput::Configure method failed. This error is returned when the caller tries to use an OPM specific command while the video output has COPP semantics only";
    case ERROR_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED                               : return "The IOPMVideoOutput::COPPCompatibleGetInformation or IOPMVideoOutput::Configure method failed because the display driver does not support the OPM_GET_ACP_AND_CGMSA_SIGNALING and OPM_SET_ACP_AND_CGMSA_SIGNALING GUIDs";
    case ERROR_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST                         : return "The IOPMVideoOutput::Configure function returns this error code if the passed in sequence number is not the expected sequence number or the passed in OMAC value is invalid";
    case ERROR_GRAPHICS_I2C_NOT_SUPPORTED                                         : return "The monitor connected to the specified video output does not have an I2C bus";
    case ERROR_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST                                 : return "No device on the I2C bus has the specified address";
    case ERROR_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA                               : return "An error occurred while transmitting data to the device on the I2C bus";
    case ERROR_GRAPHICS_I2C_ERROR_RECEIVING_DATA                                  : return "An error occurred while receiving data from the device on the I2C bus";
    case ERROR_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED                                   : return "The monitor does not support the specified VCP code";
    case ERROR_GRAPHICS_DDCCI_INVALID_DATA                                        : return "The data received from the monitor is invalid";
    case ERROR_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE         : return "The function failed because a monitor returned an invalid Timing Status byte when the operating system used the DDC/CI Get Timing Report & Timing Message command to get a timing report from a monitor";
    case ERROR_GRAPHICS_MCA_INVALID_CAPABILITIES_STRING                           : return "The monitor returned a DDC/CI capabilities string which did not comply with the ACCESS.bus 3.0, DDC/CI 1.1, or MCCS 2 Revision 1 specification";
    case ERROR_GRAPHICS_MCA_INTERNAL_ERROR                                        : return "An internal Monitor Configuration API error occurred";
    case ERROR_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND                             : return "An operation failed because a DDC/CI message had an invalid value in its command field";
    case ERROR_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH                              : return "An error occurred because the field length of a DDC/CI message contained an invalid value";
    case ERROR_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM                            : return "An error occurred because the checksum field in a DDC/CI message did not match the message's computed checksum value. This error implies that the data was corrupted while it was being transmitted from a monitor to a computer";
    case ERROR_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE                           : return "This function failed because an invalid monitor handle was passed to it";
    case ERROR_GRAPHICS_MONITOR_NO_LONGER_EXISTS                                  : return "The operating system asynchronously destroyed the monitor which corresponds to this handle because the operating system's state changed. This error typically occurs because the monitor PDO associated with this handle was removed, the monitor PDO associated with this handle was stopped, or a display mode change occurred. A display mode change occurs when windows sends a WM_DISPLAYCHANGE windows message to applications";
    case ERROR_GRAPHICS_DDCCI_CURRENT_CURRENT_VALUE_GREATER_THAN_MAXIMUM_VALUE    : return "A continuous VCP code's current value is greater than its maximum value. This error code indicates that a monitor returned an invalid value";
    case ERROR_GRAPHICS_MCA_INVALID_VCP_VERSION                                   : return "The monitor's VCP Version (0xDF) VCP code returned an invalid version value";
    case ERROR_GRAPHICS_MCA_MONITOR_VIOLATES_MCCS_SPECIFICATION                   : return "The monitor does not comply with the MCCS specification it claims to support";
    case ERROR_GRAPHICS_MCA_MCCS_VERSION_MISMATCH                                 : return "The MCCS version in a monitor's mccs_ver capability does not match the MCCS version the monitor reports when the VCP Version (0xDF) VCP code is used";
    case ERROR_GRAPHICS_MCA_UNSUPPORTED_MCCS_VERSION                              : return "The Monitor Configuration API only works with monitors which support the MCCS 1.0 specification, MCCS 2.0 specification or the MCCS 2.0 Revision 1 specification";
    case ERROR_GRAPHICS_MCA_INVALID_TECHNOLOGY_TYPE_RETURNED                      : return "The monitor returned an invalid monitor technology type. CRT, Plasma and LCD (TFT) are examples of monitor technology types. This error implies that the monitor violated the MCCS 2.0 or MCCS 2.0 Revision 1 specification";
    case ERROR_GRAPHICS_MCA_UNSUPPORTED_COLOR_TEMPERATURE                         : return "SetMonitorColorTemperature()'s caller passed a color temperature to it which the current monitor did not support. This error implies that the monitor violated the MCCS 2.0 or MCCS 2.0 Revision 1 specification";
    case ERROR_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED                            : return "This function can only be used if a program is running in the local console session. It cannot be used if the program is running on a remote desktop session or on a terminal server session";
    case ERROR_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME                     : return "This function cannot find an actual GDI display device which corresponds to the specified GDI display device name";
    case ERROR_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP                    : return "The function failed because the specified GDI display device was not attached to the Windows desktop";
    case ERROR_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED                           : return "This function does not support GDI mirroring display devices because GDI mirroring display devices do not have any physical monitors associated with them";
    case ERROR_GRAPHICS_INVALID_POINTER                                           : return "The function failed because an invalid pointer parameter was passed to it. A pointer parameter is invalid if it is NULL, points to an invalid address, points to a kernel mode address, or is not correctly aligned";
    case ERROR_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE                  : return "The function failed because the specified GDI device did not have any monitors associated with it";
    case ERROR_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL                                 : return "An array passed to the function cannot hold all of the data that the function must copy into the array";
    case ERROR_GRAPHICS_INTERNAL_ERROR                                            : return "An internal error caused an operation to fail";
    case ERROR_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS                           : return "The function failed because the current session is changing its type. This function cannot be called when the current session is changing its type. There are currently three types of sessions: console, disconnected and remote";
    case NAP_E_INVALID_PACKET                                                     : return "The NAP SoH packet is invalid";
    case NAP_E_MISSING_SOH                                                        : return "An SoH was missing from the NAP packet";
    case NAP_E_CONFLICTING_ID                                                     : return "The entity ID conflicts with an already registered id";
    case NAP_E_NO_CACHED_SOH                                                      : return "No cached SoH is present";
    case NAP_E_STILL_BOUND                                                        : return "The entity is still bound to the NAP system";
    case NAP_E_NOT_REGISTERED                                                     : return "The entity is not registered with the NAP system";
    case NAP_E_NOT_INITIALIZED                                                    : return "The entity is not initialized with the NAP system";
    case NAP_E_MISMATCHED_ID                                                      : return "The correlation id in the SoH-Request and SoH-Response do not match up";
    case NAP_E_NOT_PENDING                                                        : return "Completion was indicated on a request that is not currently pending";
    case NAP_E_ID_NOT_FOUND                                                       : return "The NAP component's id was not found";
    case NAP_E_MAXSIZE_TOO_SMALL                                                  : return "The maximum size of the connection is too small for an SoH packet";
    case NAP_E_SERVICE_NOT_RUNNING                                                : return "The NapAgent service is not running";
    case NAP_S_CERT_ALREADY_PRESENT                                               : return "A certificate is already present in the cert store";
    case NAP_E_ENTITY_DISABLED                                                    : return "The entity is disabled with the NapAgent service";
    case NAP_E_NETSH_GROUPPOLICY_ERROR                                            : return "Group Policy is not configured";
    case NAP_E_TOO_MANY_CALLS                                                     : return "Too many simultaneous calls";
    case NAP_E_SHV_CONFIG_EXISTED                                                 : return "SHV configuration already existed";
    case NAP_E_SHV_CONFIG_NOT_FOUND                                               : return "SHV configuration is not found";
    case NAP_E_SHV_TIMEOUT                                                        : return "SHV timed out on the request";
    case TPM_E_ERROR_MASK                                                         : return "This is an error mask to convert TPM hardware errors to win errors";
    case TPM_E_AUTHFAIL                                                           : return "Authentication failed";
    case TPM_E_BADINDEX                                                           : return "The index to a PCR, DIR or other register is incorrect";
    case TPM_E_BAD_PARAMETER                                                      : return "One or more parameter is bad";
    case TPM_E_AUDITFAILURE                                                       : return "An operation completed successfully but the auditing of that operation failed";
    case TPM_E_CLEAR_DISABLED                                                     : return "The clear disable flag is set and all clear operations now require physical access";
    case TPM_E_DEACTIVATED                                                        : return "Activate the Trusted Platform Module (TPM)";
    case TPM_E_DISABLED                                                           : return "Enable the Trusted Platform Module (TPM)";
    case TPM_E_DISABLED_CMD                                                       : return "The target command has been disabled";
    case TPM_E_FAIL                                                               : return "The operation failed";
    case TPM_E_BAD_ORDINAL                                                        : return "The ordinal was unknown or inconsistent";
    case TPM_E_INSTALL_DISABLED                                                   : return "The ability to install an owner is disabled";
    case TPM_E_INVALID_KEYHANDLE                                                  : return "The key handle cannot be interpreted";
    case TPM_E_KEYNOTFOUND                                                        : return "The key handle points to an invalid key";
    case TPM_E_INAPPROPRIATE_ENC                                                  : return "Unacceptable encryption scheme";
    case TPM_E_MIGRATEFAIL                                                        : return "Migration authorization failed";
    case TPM_E_INVALID_PCR_INFO                                                   : return "PCR information could not be interpreted";
    case TPM_E_NOSPACE                                                            : return "No room to load key";
    case TPM_E_NOSRK                                                              : return "There is no Storage Root Key (SRK) set";
    case TPM_E_NOTSEALED_BLOB                                                     : return "An encrypted blob is invalid or was not created by this TPM";
    case TPM_E_OWNER_SET                                                          : return "The Trusted Platform Module (TPM) already has an owner";
    case TPM_E_RESOURCES                                                          : return "The TPM has insufficient internal resources to perform the requested action";
    case TPM_E_SHORTRANDOM                                                        : return "A random string was too short";
    case TPM_E_SIZE                                                               : return "The TPM does not have the space to perform the operation";
    case TPM_E_WRONGPCRVAL                                                        : return "The named PCR value does not match the current PCR value";
    case TPM_E_BAD_PARAM_SIZE                                                     : return "The paramSize argument to the command has the incorrect value ";
    case TPM_E_SHA_THREAD                                                         : return "There is no existing SHA-1 thread";
    case TPM_E_SHA_ERROR                                                          : return "The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error";
    case TPM_E_FAILEDSELFTEST                                                     : return "The TPM hardware device reported a failure during its internal self test. Try restarting the computer to resolve the problem. If the problem continues, check for the latest BIOS or firmware update for your TPM hardware. Consult the computer manufacturer's documentation for instructions";
    case TPM_E_AUTH2FAIL                                                          : return "The authorization for the second key in a 2 key function failed authorization";
    case TPM_E_BADTAG                                                             : return "The tag value sent to for a command is invalid";
    case TPM_E_IOERROR                                                            : return "An IO error occurred transmitting information to the TPM";
    case TPM_E_ENCRYPT_ERROR                                                      : return "The encryption process had a problem";
    case TPM_E_DECRYPT_ERROR                                                      : return "The decryption process did not complete";
    case TPM_E_INVALID_AUTHHANDLE                                                 : return "An invalid handle was used";
    case TPM_E_NO_ENDORSEMENT                                                     : return "The TPM does not have an Endorsement Key (EK) installed";
    case TPM_E_INVALID_KEYUSAGE                                                   : return "The usage of a key is not allowed";
    case TPM_E_WRONG_ENTITYTYPE                                                   : return "The submitted entity type is not allowed";
    case TPM_E_INVALID_POSTINIT                                                   : return "The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup";
    case TPM_E_INAPPROPRIATE_SIG                                                  : return "Signed data cannot include additional DER information";
    case TPM_E_BAD_KEY_PROPERTY                                                   : return "The key properties in TPM_KEY_PARMs are not supported by this TPM";
    case TPM_E_BAD_MIGRATION                                                      : return "The migration properties of this key are incorrect";
    case TPM_E_BAD_SCHEME                                                         : return "The signature or encryption scheme for this key is incorrect or not permitted in this situation";
    case TPM_E_BAD_DATASIZE                                                       : return "The size of the data (or blob) parameter is bad or inconsistent with the referenced key";
    case TPM_E_BAD_MODE                                                           : return "A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob";
    case TPM_E_BAD_PRESENCE                                                       : return "Either the physicalPresence or physicalPresenceLock bits have the wrong value";
    case TPM_E_BAD_VERSION                                                        : return "The TPM cannot perform this version of the capability";
    case TPM_E_NO_WRAP_TRANSPORT                                                  : return "The TPM does not allow for wrapped transport sessions";
    case TPM_E_AUDITFAIL_UNSUCCESSFUL                                             : return "TPM audit construction failed and the underlying command was returning a failure code also";
    case TPM_E_AUDITFAIL_SUCCESSFUL                                               : return "TPM audit construction failed and the underlying command was returning success";
    case TPM_E_NOTRESETABLE                                                       : return "Attempt to reset a PCR register that does not have the resettable attribute";
    case TPM_E_NOTLOCAL                                                           : return "Attempt to reset a PCR register that requires locality and locality modifier not part of command transport";
    case TPM_E_BAD_TYPE                                                           : return "Make identity blob not properly typed";
    case TPM_E_INVALID_RESOURCE                                                   : return "When saving context identified resource type does not match actual resource";
    case TPM_E_NOTFIPS                                                            : return "The TPM is attempting to execute a command only available when in FIPS mode";
    case TPM_E_INVALID_FAMILY                                                     : return "The command is attempting to use an invalid family ID";
    case TPM_E_NO_NV_PERMISSION                                                   : return "The permission to manipulate the NV storage is not available";
    case TPM_E_REQUIRES_SIGN                                                      : return "The operation requires a signed command";
    case TPM_E_KEY_NOTSUPPORTED                                                   : return "Wrong operation to load an NV key";
    case TPM_E_AUTH_CONFLICT                                                      : return "NV_LoadKey blob requires both owner and blob authorization";
    case TPM_E_AREA_LOCKED                                                        : return "The NV area is locked and not writtable";
    case TPM_E_BAD_LOCALITY                                                       : return "The locality is incorrect for the attempted operation";
    case TPM_E_READ_ONLY                                                          : return "The NV area is read only and can't be written to";
    case TPM_E_PER_NOWRITE                                                        : return "There is no protection on the write to the NV area";
    case TPM_E_FAMILYCOUNT                                                        : return "The family count value does not match";
    case TPM_E_WRITE_LOCKED                                                       : return "The NV area has already been written to";
    case TPM_E_BAD_ATTRIBUTES                                                     : return "The NV area attributes conflict";
    case TPM_E_INVALID_STRUCTURE                                                  : return "The structure tag and version are invalid or inconsistent";
    case TPM_E_KEY_OWNER_CONTROL                                                  : return "The key is under control of the TPM Owner and can only be evicted by the TPM Owner";
    case TPM_E_BAD_COUNTER                                                        : return "The counter handle is incorrect";
    case TPM_E_NOT_FULLWRITE                                                      : return "The write is not a complete write of the area";
    case TPM_E_CONTEXT_GAP                                                        : return "The gap between saved context counts is too large";
    case TPM_E_MAXNVWRITES                                                        : return "The maximum number of NV writes without an owner has been exceeded";
    case TPM_E_NOOPERATOR                                                         : return "No operator AuthData value is set";
    case TPM_E_RESOURCEMISSING                                                    : return "The resource pointed to by context is not loaded";
    case TPM_E_DELEGATE_LOCK                                                      : return "The delegate administration is locked";
    case TPM_E_DELEGATE_FAMILY                                                    : return "Attempt to manage a family other then the delegated family";
    case TPM_E_DELEGATE_ADMIN                                                     : return "Delegation table management not enabled";
    case TPM_E_TRANSPORT_NOTEXCLUSIVE                                             : return "There was a command executed outside of an exclusive transport session";
    case TPM_E_OWNER_CONTROL                                                      : return "Attempt to context save a owner evict controlled key";
    case TPM_E_DAA_RESOURCES                                                      : return "The DAA command has no resources availble to execute the command";
    case TPM_E_DAA_INPUT_DATA0                                                    : return "The consistency check on DAA parameter inputData0 has failed";
    case TPM_E_DAA_INPUT_DATA1                                                    : return "The consistency check on DAA parameter inputData1 has failed";
    case TPM_E_DAA_ISSUER_SETTINGS                                                : return "The consistency check on DAA_issuerSettings has failed";
    case TPM_E_DAA_TPM_SETTINGS                                                   : return "The consistency check on DAA_tpmSpecific has failed";
    case TPM_E_DAA_STAGE                                                          : return "The atomic process indicated by the submitted DAA command is not the expected process";
    case TPM_E_DAA_ISSUER_VALIDITY                                                : return "The issuer's validity check has detected an inconsistency";
    case TPM_E_DAA_WRONG_W                                                        : return "The consistency check on w has failed";
    case TPM_E_BAD_HANDLE                                                         : return "The handle is incorrect";
    case TPM_E_BAD_DELEGATE                                                       : return "Delegation is not correct";
    case TPM_E_BADCONTEXT                                                         : return "The context blob is invalid";
    case TPM_E_TOOMANYCONTEXTS                                                    : return "Too many contexts held by the TPM";
    case TPM_E_MA_TICKET_SIGNATURE                                                : return "Migration authority signature validation failure";
    case TPM_E_MA_DESTINATION                                                     : return "Migration destination not authenticated";
    case TPM_E_MA_SOURCE                                                          : return "Migration source incorrect";
    case TPM_E_MA_AUTHORITY                                                       : return "Incorrect migration authority";
    case TPM_E_PERMANENTEK                                                        : return "Attempt to revoke the EK and the EK is not revocable";
    case TPM_E_BAD_SIGNATURE                                                      : return "Bad signature of CMK ticket";
    case TPM_E_NOCONTEXTSPACE                                                     : return "There is no room in the context list for additional contexts";
    case TPM_E_COMMAND_BLOCKED                                                    : return "The command was blocked";
    case TPM_E_INVALID_HANDLE                                                     : return "The specified handle was not found";
    case TPM_E_DUPLICATE_VHANDLE                                                  : return "The TPM returned a duplicate handle and the command needs to be resubmitted";
    case TPM_E_EMBEDDED_COMMAND_BLOCKED                                           : return "The command within the transport was blocked";
    case TPM_E_EMBEDDED_COMMAND_UNSUPPORTED                                       : return "The command within the transport is not supported";
    case TPM_E_RETRY                                                              : return "The TPM is too busy to respond to the command immediately, but the command could be resubmitted at a later time";
    case TPM_E_NEEDS_SELFTEST                                                     : return "SelfTestFull has not been run";
    case TPM_E_DOING_SELFTEST                                                     : return "The TPM is currently executing a full selftest";
    case TPM_E_DEFEND_LOCK_RUNNING                                                : return "The TPM is defending against dictionary attacks and is in a time-out period";
    case TBS_E_INTERNAL_ERROR                                                     : return "An internal error has occurred within the Trusted Platform Module support program";
    case TBS_E_BAD_PARAMETER                                                      : return "One or more input parameters is bad";
    case TBS_E_INVALID_OUTPUT_POINTER                                             : return "A specified output pointer is bad";
    case TBS_E_INVALID_CONTEXT                                                    : return "The specified context handle does not refer to a valid context";
    case TBS_E_INSUFFICIENT_BUFFER                                                : return "A specified output buffer is too small";
    case TBS_E_IOERROR                                                            : return "An error occurred while communicating with the TPM";
    case TBS_E_INVALID_CONTEXT_PARAM                                              : return "One or more context parameters is invalid";
    case TBS_E_SERVICE_NOT_RUNNING                                                : return "The TBS service is not running and could not be started";
    case TBS_E_TOO_MANY_TBS_CONTEXTS                                              : return "A new context could not be created because there are too many open contexts";
    case TBS_E_TOO_MANY_RESOURCES                                                 : return "A new virtual resource could not be created because there are too many open virtual resources";
    case TBS_E_SERVICE_START_PENDING                                              : return "The TBS service has been started but is not yet running";
    case TBS_E_PPI_NOT_SUPPORTED                                                  : return "The physical presence interface is not supported";
    case TBS_E_COMMAND_CANCELED                                                   : return "The command was canceled";
    case TBS_E_BUFFER_TOO_LARGE                                                   : return "The input or output buffer is too large";
    case TBS_E_TPM_NOT_FOUND                                                      : return "A compatible Trusted Platform Module (TPM) Security Device cannot be found on this computer";
    case TBS_E_SERVICE_DISABLED                                                   : return "The TBS service has been disabled";
    case TBS_E_NO_EVENT_LOG                                                       : return "No TCG event log is available";
    case TBS_E_ACCESS_DENIED                                                      : return "The caller does not have the appropriate rights to perform the requested operation";
    case TBS_E_PROVISIONING_NOT_ALLOWED                                           : return "The TPM provisioning action is not allowed by the specified flags.  For provisioning to be successful, one of several actions may be required.  The TPM management console (tpm.msc) action to make the TPM Ready may help.  For further information, see the documentation for the Win32_Tpm WMI method 'Provision'.  (The actions that may be required include importing the TPM Owner Authorization value into the system, calling the Win32_Tpm WMI method for provisioning the TPM and specifying TRUE for either 'ForceClear_Allowed' or 'PhysicalPresencePrompts_Allowed' (as indicated by the value returned in the Additional Information), or enabling the TPM in the system BIOS.)";
    case TBS_E_PPI_FUNCTION_UNSUPPORTED                                           : return "The Physical Presence Interface of this firmware does not support the requested method";
    case TBS_E_OWNERAUTH_NOT_FOUND                                                : return "The requested TPM OwnerAuth value was not found";
    case TBS_E_PROVISIONING_INCOMPLETE                                            : return "The TPM provisioning did not complete.  For more information on completing the provisioning, call the Win32_Tpm WMI method for provisioning the TPM ('Provision') and check the returned Information";
    case TPMAPI_E_INVALID_STATE                                                   : return "The command buffer is not in the correct state";
    case TPMAPI_E_NOT_ENOUGH_DATA                                                 : return "The command buffer does not contain enough data to satisfy the request";
    case TPMAPI_E_TOO_MUCH_DATA                                                   : return "The command buffer cannot contain any more data";
    case TPMAPI_E_INVALID_OUTPUT_POINTER                                          : return "One or more output parameters was NULL or invalid";
    case TPMAPI_E_INVALID_PARAMETER                                               : return "One or more input parameters is invalid";
    case TPMAPI_E_OUT_OF_MEMORY                                                   : return "Not enough memory was available to satisfy the request";
    case TPMAPI_E_BUFFER_TOO_SMALL                                                : return "The specified buffer was too small";
    case TPMAPI_E_INTERNAL_ERROR                                                  : return "An internal error was detected";
    case TPMAPI_E_ACCESS_DENIED                                                   : return "The caller does not have the appropriate rights to perform the requested operation";
    case TPMAPI_E_AUTHORIZATION_FAILED                                            : return "The specified authorization information was invalid";
    case TPMAPI_E_INVALID_CONTEXT_HANDLE                                          : return "The specified context handle was not valid";
    case TPMAPI_E_TBS_COMMUNICATION_ERROR                                         : return "An error occurred while communicating with the TBS";
    case TPMAPI_E_TPM_COMMAND_ERROR                                               : return "The TPM returned an unexpected result";
    case TPMAPI_E_MESSAGE_TOO_LARGE                                               : return "The message was too large for the encoding scheme";
    case TPMAPI_E_INVALID_ENCODING                                                : return "The encoding in the blob was not recognized";
    case TPMAPI_E_INVALID_KEY_SIZE                                                : return "The key size is not valid";
    case TPMAPI_E_ENCRYPTION_FAILED                                               : return "The encryption operation failed";
    case TPMAPI_E_INVALID_KEY_PARAMS                                              : return "The key parameters structure was not valid";
    case TPMAPI_E_INVALID_MIGRATION_AUTHORIZATION_BLOB                            : return "The requested supplied data does not appear to be a valid migration authorization blob";
    case TPMAPI_E_INVALID_PCR_INDEX                                               : return "The specified PCR index was invalid";
    case TPMAPI_E_INVALID_DELEGATE_BLOB                                           : return "The data given does not appear to be a valid delegate blob";
    case TPMAPI_E_INVALID_CONTEXT_PARAMS                                          : return "One or more of the specified context parameters was not valid";
    case TPMAPI_E_INVALID_KEY_BLOB                                                : return "The data given does not appear to be a valid key blob";
    case TPMAPI_E_INVALID_PCR_DATA                                                : return "The specified PCR data was invalid";
    case TPMAPI_E_INVALID_OWNER_AUTH                                              : return "The format of the owner auth data was invalid";
    case TPMAPI_E_FIPS_RNG_CHECK_FAILED                                           : return "The random number generated did not pass FIPS RNG check";
    case TPMAPI_E_EMPTY_TCG_LOG                                                   : return "The TCG Event Log does not contain any data";
    case TPMAPI_E_INVALID_TCG_LOG_ENTRY                                           : return "An entry in the TCG Event Log was invalid";
    case TPMAPI_E_TCG_SEPARATOR_ABSENT                                            : return "A TCG Separator was not found";
    case TPMAPI_E_TCG_INVALID_DIGEST_ENTRY                                        : return "A digest value in a TCG Log entry did not match hashed data";
    case TPMAPI_E_POLICY_DENIES_OPERATION                                         : return "The requested operation was blocked by current TPM policy. Please contact your system administrator for assistance";
    case TBSIMP_E_BUFFER_TOO_SMALL                                                : return "The specified buffer was too small";
    case TBSIMP_E_CLEANUP_FAILED                                                  : return "The context could not be cleaned up";
    case TBSIMP_E_INVALID_CONTEXT_HANDLE                                          : return "The specified context handle is invalid";
    case TBSIMP_E_INVALID_CONTEXT_PARAM                                           : return "An invalid context parameter was specified";
    case TBSIMP_E_TPM_ERROR                                                       : return "An error occurred while communicating with the TPM";
    case TBSIMP_E_HASH_BAD_KEY                                                    : return "No entry with the specified key was found";
    case TBSIMP_E_DUPLICATE_VHANDLE                                               : return "The specified virtual handle matches a virtual handle already in use";
    case TBSIMP_E_INVALID_OUTPUT_POINTER                                          : return "The pointer to the returned handle location was NULL or invalid";
    case TBSIMP_E_INVALID_PARAMETER                                               : return "One or more parameters is invalid";
    case TBSIMP_E_RPC_INIT_FAILED                                                 : return "The RPC subsystem could not be initialized";
    case TBSIMP_E_SCHEDULER_NOT_RUNNING                                           : return "The TBS scheduler is not running";
    case TBSIMP_E_COMMAND_CANCELED                                                : return "The command was canceled";
    case TBSIMP_E_OUT_OF_MEMORY                                                   : return "There was not enough memory to fulfill the request";
    case TBSIMP_E_LIST_NO_MORE_ITEMS                                              : return "The specified list is empty, or the iteration has reached the end of the list";
    case TBSIMP_E_LIST_NOT_FOUND                                                  : return "The specified item was not found in the list";
    case TBSIMP_E_NOT_ENOUGH_SPACE                                                : return "The TPM does not have enough space to load the requested resource";
    case TBSIMP_E_NOT_ENOUGH_TPM_CONTEXTS                                         : return "There are too many TPM contexts in use";
    case TBSIMP_E_COMMAND_FAILED                                                  : return "The TPM command failed";
    case TBSIMP_E_UNKNOWN_ORDINAL                                                 : return "The TBS does not recognize the specified ordinal";
    case TBSIMP_E_RESOURCE_EXPIRED                                                : return "The requested resource is no longer available";
    case TBSIMP_E_INVALID_RESOURCE                                                : return "The resource type did not match";
    case TBSIMP_E_NOTHING_TO_UNLOAD                                               : return "No resources can be unloaded";
    case TBSIMP_E_HASH_TABLE_FULL                                                 : return "No new entries can be added to the hash table";
    case TBSIMP_E_TOO_MANY_TBS_CONTEXTS                                           : return "A new TBS context could not be created because there are too many open contexts";
    case TBSIMP_E_TOO_MANY_RESOURCES                                              : return "A new virtual resource could not be created because there are too many open virtual resources";
    case TBSIMP_E_PPI_NOT_SUPPORTED                                               : return "The physical presence interface is not supported";
    case TBSIMP_E_TPM_INCOMPATIBLE                                                : return "TBS is not compatible with the version of TPM found on the system";
    case TBSIMP_E_NO_EVENT_LOG                                                    : return "No TCG event log is available";
    case TPM_E_PPI_ACPI_FAILURE                                                   : return "A general error was detected when attempting to acquire the BIOS's response to a Physical Presence command";
    case TPM_E_PPI_USER_ABORT                                                     : return "The user failed to confirm the TPM operation request";
    case TPM_E_PPI_BIOS_FAILURE                                                   : return "The BIOS failure prevented the successful execution of the requested TPM operation (e.g. invalid TPM operation request, BIOS communication error with the TPM)";
    case TPM_E_PPI_NOT_SUPPORTED                                                  : return "The BIOS does not support the physical presence interface";
    case TPM_E_PPI_BLOCKED_IN_BIOS                                                : return "The Physical Presence command was blocked by current BIOS settings. The system owner may be able to reconfigure the BIOS settings to allow the command";
    case TPM_E_PCP_ERROR_MASK                                                     : return "This is an error mask to convert Platform Crypto Provider errors to win errors";
    case TPM_E_PCP_DEVICE_NOT_READY                                               : return "The Platform Crypto Device is currently not ready. It needs to be fully provisioned to be operational";
    case TPM_E_PCP_INVALID_HANDLE                                                 : return "The handle provided to the Platform Crypto Provider is invalid";
    case TPM_E_PCP_INVALID_PARAMETER                                              : return "A parameter provided to the Platform Crypto Provider is invalid";
    case TPM_E_PCP_FLAG_NOT_SUPPORTED                                             : return "A provided flag to the Platform Crypto Provider is not supported";
    case TPM_E_PCP_NOT_SUPPORTED                                                  : return "The requested operation is not supported by this Platform Crypto Provider";
    case TPM_E_PCP_BUFFER_TOO_SMALL                                               : return "The buffer is too small to contain all data. No information has been written to the buffer";
    case TPM_E_PCP_INTERNAL_ERROR                                                 : return "An unexpected internal error has occurred in the Platform Crypto Provider";
    case TPM_E_PCP_AUTHENTICATION_FAILED                                          : return "The authorization to use a provider object has failed";
    case TPM_E_PCP_AUTHENTICATION_IGNORED                                         : return "The Platform Crypto Device has ignored the authorization for the provider object, to mitigate against a dictionary attack";
    case TPM_E_PCP_POLICY_NOT_FOUND                                               : return "The referenced policy was not found";
    case TPM_E_PCP_PROFILE_NOT_FOUND                                              : return "The referenced profile was not found";
    case TPM_E_PCP_VALIDATION_FAILED                                              : return "The validation was not succesful";
    case TPM_E_PCP_WRONG_PARENT                                                   : return "An attempt was made to import or load a key under an incorrect storage parent";
    case TPM_E_KEY_NOT_LOADED                                                     : return "The TPM key is not loaded";
    case TPM_E_NO_KEY_CERTIFICATION                                               : return "The TPM key certification has not been generated";
    case TPM_E_KEY_NOT_FINALIZED                                                  : return "The TPM key is not yet finalized";
    case TPM_E_ATTESTATION_CHALLENGE_NOT_SET                                      : return "The TPM attestation challenge is not set";
    case TPM_E_NOT_PCR_BOUND                                                      : return "The TPM PCR info is not available";
    case TPM_E_KEY_ALREADY_FINALIZED                                              : return "The TPM key is already finalized";
    case TPM_E_KEY_USAGE_POLICY_NOT_SUPPORTED                                     : return "The TPM key usage policy is not supported";
    case TPM_E_KEY_USAGE_POLICY_INVALID                                           : return "The TPM key usage policy is invalid";
    case TPM_E_SOFT_KEY_ERROR                                                     : return "There was a problem with the software key being imported into the TPM";
    case TPM_E_KEY_NOT_AUTHENTICATED                                              : return "The TPM key is not authenticated";
    case TPM_E_PCP_KEY_NOT_AIK                                                    : return "The TPM key is not an AIK";
    case TPM_E_KEY_NOT_SIGNING_KEY                                                : return "The TPM key is not a signing key";
    case TPM_E_LOCKED_OUT                                                         : return "The TPM is locked out";
    case TPM_E_CLAIM_TYPE_NOT_SUPPORTED                                           : return "The claim type requested is not supported";
    case TPM_E_VERSION_NOT_SUPPORTED                                              : return "TPM version is not supported";
    case TPM_E_BUFFER_LENGTH_MISMATCH                                             : return "The buffer lengths do not match";
    case TPM_E_PCP_IFX_RSA_KEY_CREATION_BLOCKED                                   : return "The RSA key creation is blocked on this TPM due to known security vulnerabilities";
    case TPM_E_ZERO_EXHAUST_ENABLED                                               : return "TPM related network operations are blocked as Zero Exhaust mode is enabled on client";
    case PLA_E_DCS_NOT_FOUND                                                      : return "Data Collector Set was not found";
    case PLA_E_DCS_IN_USE                                                         : return "The Data Collector Set or one of its dependencies is already in use";
    case PLA_E_TOO_MANY_FOLDERS                                                   : return "Unable to start Data Collector Set because there are too many folders";
    case PLA_E_NO_MIN_DISK                                                        : return "Not enough free disk space to start Data Collector Set";
    case PLA_E_DCS_ALREADY_EXISTS                                                 : return "Data Collector Set already exists";
    case PLA_S_PROPERTY_IGNORED                                                   : return "Property value will be ignored";
    case PLA_E_PROPERTY_CONFLICT                                                  : return "Property value conflict";
    case PLA_E_DCS_SINGLETON_REQUIRED                                             : return "The current configuration for this Data Collector Set requires that it contain exactly one Data Collector";
    case PLA_E_CREDENTIALS_REQUIRED                                               : return "A user account is required in order to commit the current Data Collector Set properties";
    case PLA_E_DCS_NOT_RUNNING                                                    : return "Data Collector Set is not running";
    case PLA_E_CONFLICT_INCL_EXCL_API                                             : return "A conflict was detected in the list of include/exclude APIs. Do not specify the same API in both the include list and the exclude list";
    case PLA_E_NETWORK_EXE_NOT_VALID                                              : return "The executable path you have specified refers to a network share or UNC path";
    case PLA_E_EXE_ALREADY_CONFIGURED                                             : return "The executable path you have specified is already configured for API tracing";
    case PLA_E_EXE_PATH_NOT_VALID                                                 : return "The executable path you have specified does not exist. Verify that the specified path is correct";
    case PLA_E_DC_ALREADY_EXISTS                                                  : return "Data Collector already exists";
    case PLA_E_DCS_START_WAIT_TIMEOUT                                             : return "The wait for the Data Collector Set start notification has timed out";
    case PLA_E_DC_START_WAIT_TIMEOUT                                              : return "The wait for the Data Collector to start has timed out";
    case PLA_E_REPORT_WAIT_TIMEOUT                                                : return "The wait for the report generation tool to finish has timed out";
    case PLA_E_NO_DUPLICATES                                                      : return "Duplicate items are not allowed";
    case PLA_E_EXE_FULL_PATH_REQUIRED                                             : return "When specifying the executable that you want to trace, you must specify a full path to the executable and not just a filename";
    case PLA_E_INVALID_SESSION_NAME                                               : return "The session name provided is invalid";
    case PLA_E_PLA_CHANNEL_NOT_ENABLED                                            : return "The Event Log channel Microsoft-Windows-Diagnosis-PLA/Operational must be enabled to perform this operation";
    case PLA_E_TASKSCHED_CHANNEL_NOT_ENABLED                                      : return "The Event Log channel Microsoft-Windows-TaskScheduler must be enabled to perform this operation";
    case PLA_E_RULES_MANAGER_FAILED                                               : return "The execution of the Rules Manager failed";
    case PLA_E_CABAPI_FAILURE                                                     : return "An error occurred while attempting to compress or extract the data";
    case FVE_E_LOCKED_VOLUME                                                      : return "This drive is locked by BitLocker Drive Encryption. You must unlock this drive from Control Panel";
    case FVE_E_NOT_ENCRYPTED                                                      : return "This drive is not encrypted";
    case FVE_E_NO_TPM_BIOS                                                        : return "The BIOS did not correctly communicate with the Trusted Platform Module (TPM). Contact the computer manufacturer for BIOS upgrade instructions";
    case FVE_E_NO_MBR_METRIC                                                      : return "The BIOS did not correctly communicate with the master boot record (MBR). Contact the computer manufacturer for BIOS upgrade instructions";
    case FVE_E_NO_BOOTSECTOR_METRIC                                               : return "A required TPM measurement is missing. If there is a bootable CD or DVD in your computer, remove it, restart the computer, and turn on BitLocker again. If the problem persists, ensure the master boot record is up to date";
    case FVE_E_NO_BOOTMGR_METRIC                                                  : return "The boot sector of this drive is not compatible with BitLocker Drive Encryption. Use the Bootrec.exe tool in the Windows Recovery Environment to update or repair the boot manager (BOOTMGR)";
    case FVE_E_WRONG_BOOTMGR                                                      : return "The boot manager of this operating system is not compatible with BitLocker Drive Encryption. Use the Bootrec.exe tool in the Windows Recovery Environment to update or repair the boot manager (BOOTMGR)";
    case FVE_E_SECURE_KEY_REQUIRED                                                : return "At least one secure key protector is required for this operation to be performed";
    case FVE_E_NOT_ACTIVATED                                                      : return "BitLocker Drive Encryption is not enabled on this drive. Turn on BitLocker";
    case FVE_E_ACTION_NOT_ALLOWED                                                 : return "BitLocker Drive Encryption cannot perform the requested action. This condition may occur when two requests are issued at the same time. Wait a few moments and then try the action again";
    case FVE_E_AD_SCHEMA_NOT_INSTALLED                                            : return "The Active Directory Domain Services forest does not contain the required attributes and classes to host BitLocker Drive Encryption or Trusted Platform Module information. Contact your domain administrator to verify that any required BitLocker Active Directory schema extensions have been installed";
    case FVE_E_AD_INVALID_DATATYPE                                                : return "The type of the data obtained from Active Directory was not expected. The BitLocker recovery information may be missing or corrupted";
    case FVE_E_AD_INVALID_DATASIZE                                                : return "The size of the data obtained from Active Directory was not expected. The BitLocker recovery information may be missing or corrupted";
    case FVE_E_AD_NO_VALUES                                                       : return "The attribute read from Active Directory does not contain any values. The BitLocker recovery information may be missing or corrupted";
    case FVE_E_AD_ATTR_NOT_SET                                                    : return "The attribute was not set. Verify that you are logged on with a domain account that has the ability to write information to Active Directory objects";
    case FVE_E_AD_GUID_NOT_FOUND                                                  : return "The specified attribute cannot be found in Active Directory Domain Services. Contact your domain administrator to verify that any required BitLocker Active Directory schema extensions have been installed";
    case FVE_E_BAD_INFORMATION                                                    : return "The BitLocker metadata for the encrypted drive is not valid. You can attempt to repair the drive to restore access";
    case FVE_E_TOO_SMALL                                                          : return "The drive cannot be encrypted because it does not have enough free space. Delete any unnecessary data on the drive to create additional free space and then try again";
    case FVE_E_SYSTEM_VOLUME                                                      : return "The drive cannot be encrypted because it contains system boot information. Create a separate partition for use as the system drive that contains the boot information and a second partition for use as the operating system drive and then encrypt the operating system drive";
    case FVE_E_FAILED_WRONG_FS                                                    : return "The drive cannot be encrypted because the file system is not supported";
    case FVE_E_BAD_PARTITION_SIZE                                                 : return "The file system size is larger than the partition size in the partition table. This drive may be corrupt or may have been tampered with. To use it with BitLocker, you must reformat the partition";
    case FVE_E_NOT_SUPPORTED                                                      : return "This drive cannot be encrypted";
    case FVE_E_BAD_DATA                                                           : return "The data is not valid";
    case FVE_E_VOLUME_NOT_BOUND                                                   : return "The data drive specified is not set to automatically unlock on the current computer and cannot be unlocked automatically";
    case FVE_E_TPM_NOT_OWNED                                                      : return "You must initialize the Trusted Platform Module (TPM) before you can use BitLocker Drive Encryption";
    case FVE_E_NOT_DATA_VOLUME                                                    : return "The operation attempted cannot be performed on an operating system drive";
    case FVE_E_AD_INSUFFICIENT_BUFFER                                             : return "The buffer supplied to a function was insufficient to contain the returned data. Increase the buffer size before running the function again";
    case FVE_E_CONV_READ                                                          : return "A read operation failed while converting the drive. The drive was not converted. Please re-enable BitLocker";
    case FVE_E_CONV_WRITE                                                         : return "A write operation failed while converting the drive. The drive was not converted. Please re-enable BitLocker";
    case FVE_E_KEY_REQUIRED                                                       : return "One or more BitLocker key protectors are required. You cannot delete the last key on this drive";
    case FVE_E_CLUSTERING_NOT_SUPPORTED                                           : return "Cluster configurations are not supported by BitLocker Drive Encryption";
    case FVE_E_VOLUME_BOUND_ALREADY                                               : return "The drive specified is already configured to be automatically unlocked on the current computer";
    case FVE_E_OS_NOT_PROTECTED                                                   : return "The operating system drive is not protected by BitLocker Drive Encryption";
    case FVE_E_PROTECTION_DISABLED                                                : return "BitLocker Drive Encryption has been suspended on this drive. All BitLocker key protectors configured for this drive are effectively disabled, and the drive will be automatically unlocked using an unencrypted (clear) key";
    case FVE_E_RECOVERY_KEY_REQUIRED                                              : return "The drive you are attempting to lock does not have any key protectors available for encryption because BitLocker protection is currently suspended. Re-enable BitLocker to lock this drive";
    case FVE_E_FOREIGN_VOLUME                                                     : return "BitLocker cannot use the Trusted Platform Module (TPM) to protect a data drive. TPM protection can only be used with the operating system drive";
    case FVE_E_OVERLAPPED_UPDATE                                                  : return "The BitLocker metadata for the encrypted drive cannot be updated because it was locked for updating by another process. Please try this process again";
    case FVE_E_TPM_SRK_AUTH_NOT_ZERO                                              : return "The authorization data for the storage root key (SRK) of the Trusted Platform Module (TPM) is not zero and is therefore incompatible with BitLocker. Please initialize the TPM before attempting to use it with BitLocker";
    case FVE_E_FAILED_SECTOR_SIZE                                                 : return "The drive encryption algorithm cannot be used on this sector size";
    case FVE_E_FAILED_AUTHENTICATION                                              : return "The drive cannot be unlocked with the key provided. Confirm that you have provided the correct key and try again";
    case FVE_E_NOT_OS_VOLUME                                                      : return "The drive specified is not the operating system drive";
    case FVE_E_AUTOUNLOCK_ENABLED                                                 : return "BitLocker Drive Encryption cannot be turned off on the operating system drive until the auto unlock feature has been disabled for the fixed data drives and removable data drives associated with this computer";
    case FVE_E_WRONG_BOOTSECTOR                                                   : return "The system partition boot sector does not perform Trusted Platform Module (TPM) measurements. Use the Bootrec.exe tool in the Windows Recovery Environment to update or repair the boot sector";
    case FVE_E_WRONG_SYSTEM_FS                                                    : return "BitLocker Drive Encryption operating system drives must be formatted with the NTFS file system in order to be encrypted. Convert the drive to NTFS, and then turn on BitLocker";
    case FVE_E_POLICY_PASSWORD_REQUIRED                                           : return "Group Policy settings require that a recovery password be specified before encrypting the drive";
    case FVE_E_CANNOT_SET_FVEK_ENCRYPTED                                          : return "The drive encryption algorithm and key cannot be set on a previously encrypted drive. To encrypt this drive with BitLocker Drive Encryption, remove the previous encryption and then turn on BitLocker";
    case FVE_E_CANNOT_ENCRYPT_NO_KEY                                              : return "BitLocker Drive Encryption cannot encrypt the specified drive because an encryption key is not available. Add a key protector to encrypt this drive";
    case FVE_E_BOOTABLE_CDDVD                                                     : return "BitLocker Drive Encryption detected bootable media (CD or DVD) in the computer. Remove the media and restart the computer before configuring BitLocker";
    case FVE_E_PROTECTOR_EXISTS                                                   : return "This key protector cannot be added. Only one key protector of this type is allowed for this drive";
    case FVE_E_RELATIVE_PATH                                                      : return "The recovery password file was not found because a relative path was specified. Recovery passwords must be saved to a fully qualified path. Environment variables configured on the computer can be used in the path";
    case FVE_E_PROTECTOR_NOT_FOUND                                                : return "The specified key protector was not found on the drive. Try another key protector";
    case FVE_E_INVALID_KEY_FORMAT                                                 : return "The recovery key provided is corrupt and cannot be used to access the drive. An alternative recovery method, such as recovery password, a data recovery agent, or a backup version of the recovery key must be used to recover access to the drive";
    case FVE_E_INVALID_PASSWORD_FORMAT                                            : return "The format of the recovery password provided is invalid. BitLocker recovery passwords are 48 digits. Verify that the recovery password is in the correct format and then try again";
    case FVE_E_FIPS_RNG_CHECK_FAILED                                              : return "The random number generator check test failed";
    case FVE_E_FIPS_PREVENTS_RECOVERY_PASSWORD                                    : return "The Group Policy setting requiring FIPS compliance prevents a local recovery password from being generated or used by BitLocker Drive Encryption. When operating in FIPS-compliant mode, BitLocker recovery options can be either a recovery key stored on a USB drive or recovery through a data recovery agent";
    case FVE_E_FIPS_PREVENTS_EXTERNAL_KEY_EXPORT                                  : return "The Group Policy setting requiring FIPS compliance prevents the recovery password from being saved to Active Directory. When operating in FIPS-compliant mode, BitLocker recovery options can be either a recovery key stored on a USB drive or recovery through a data recovery agent. Check your Group Policy settings configuration";
    case FVE_E_NOT_DECRYPTED                                                      : return "The drive must be fully decrypted to complete this operation";
    case FVE_E_INVALID_PROTECTOR_TYPE                                             : return "The key protector specified cannot be used for this operation";
    case FVE_E_NO_PROTECTORS_TO_TEST                                              : return "No key protectors exist on the drive to perform the hardware test";
    case FVE_E_KEYFILE_NOT_FOUND                                                  : return "The BitLocker startup key or recovery password cannot be found on the USB device. Verify that you have the correct USB device, that the USB device is plugged into the computer on an active USB port, restart the computer, and then try again. If the problem persists, contact the computer manufacturer for BIOS upgrade instructions";
    case FVE_E_KEYFILE_INVALID                                                    : return "The BitLocker startup key or recovery password file provided is corrupt or invalid. Verify that you have the correct startup key or recovery password file and try again";
    case FVE_E_KEYFILE_NO_VMK                                                     : return "The BitLocker encryption key cannot be obtained from the startup key or recovery password. Verify that you have the correct startup key or recovery password and try again";
    case FVE_E_TPM_DISABLED                                                       : return "The Trusted Platform Module (TPM) is disabled. The TPM must be enabled, initialized, and have valid ownership before it can be used with BitLocker Drive Encryption";
    case FVE_E_NOT_ALLOWED_IN_SAFE_MODE                                           : return "The BitLocker configuration of the specified drive cannot be managed because this computer is currently operating in Safe Mode. While in Safe Mode, BitLocker Drive Encryption can only be used for recovery purposes";
    case FVE_E_TPM_INVALID_PCR                                                    : return "The Trusted Platform Module (TPM) was unable to unlock the drive. Either the system boot information changed after choosing BitLocker settings or the PIN did not match. If the problem persists after several tries, there may be a hardware or firmware problem";
    case FVE_E_TPM_NO_VMK                                                         : return "The BitLocker encryption key cannot be obtained from the Trusted Platform Module (TPM)";
    case FVE_E_PIN_INVALID                                                        : return "The BitLocker encryption key cannot be obtained from the Trusted Platform Module (TPM) and PIN";
    case FVE_E_AUTH_INVALID_APPLICATION                                           : return "A boot application has changed since BitLocker Drive Encryption was enabled";
    case FVE_E_AUTH_INVALID_CONFIG                                                : return "The Boot Configuration Data (BCD) settings have changed since BitLocker Drive Encryption was enabled";
    case FVE_E_FIPS_DISABLE_PROTECTION_NOT_ALLOWED                                : return "The Group Policy setting requiring FIPS compliance prohibits the use of unencrypted keys, which prevents BitLocker from being suspended on this drive. Please contact your domain administrator for more information";
    case FVE_E_FS_NOT_EXTENDED                                                    : return "This drive cannot be encrypted by BitLocker Drive Encryption because the file system does not extend to the end of the drive. Repartition this drive and then try again";
    case FVE_E_FIRMWARE_TYPE_NOT_SUPPORTED                                        : return "BitLocker Drive Encryption cannot be enabled on the operating system drive. Contact the computer manufacturer for BIOS upgrade instructions";
    case FVE_E_NO_LICENSE                                                         : return "This version of Windows does not include BitLocker Drive Encryption. To use BitLocker Drive Encryption, please upgrade the operating system";
    case FVE_E_NOT_ON_STACK                                                       : return "BitLocker Drive Encryption cannot be used because critical BitLocker system files are missing or corrupted. Use Windows Startup Repair to restore these files to your computer";
    case FVE_E_FS_MOUNTED                                                         : return "The drive cannot be locked when the drive is in use";
    case FVE_E_TOKEN_NOT_IMPERSONATED                                             : return "The access token associated with the current thread is not an impersonated token";
    case FVE_E_DRY_RUN_FAILED                                                     : return "The BitLocker encryption key cannot be obtained. Verify that the Trusted Platform Module (TPM) is enabled and ownership has been taken. If this computer does not have a TPM, verify that the USB drive is inserted and available";
    case FVE_E_REBOOT_REQUIRED                                                    : return "You must restart your computer before continuing with BitLocker Drive Encryption";
    case FVE_E_DEBUGGER_ENABLED                                                   : return "Drive encryption cannot occur while boot debugging is enabled. Use the bcdedit command-line tool to turn off boot debugging";
    case FVE_E_RAW_ACCESS                                                         : return "No action was taken as BitLocker Drive Encryption is in raw access mode";
    case FVE_E_RAW_BLOCKED                                                        : return "BitLocker Drive Encryption cannot enter raw access mode for this drive because the drive is currently in use";
    case FVE_E_BCD_APPLICATIONS_PATH_INCORRECT                                    : return "The path specified in the Boot Configuration Data (BCD) for a BitLocker Drive Encryption integrity-protected application is incorrect. Please verify and correct your BCD settings and try again";
    case FVE_E_NOT_ALLOWED_IN_VERSION                                             : return "BitLocker Drive Encryption can only be used for limited provisioning or recovery purposes when the computer is running in pre-installation or recovery environments";
    case FVE_E_NO_AUTOUNLOCK_MASTER_KEY                                           : return "The auto-unlock master key was not available from the operating system drive";
    case FVE_E_MOR_FAILED                                                         : return "The system firmware failed to enable clearing of system memory when the computer was restarted";
    case FVE_E_HIDDEN_VOLUME                                                      : return "The hidden drive cannot be encrypted";
    case FVE_E_TRANSIENT_STATE                                                    : return "BitLocker encryption keys were ignored because the drive was in a transient state";
    case FVE_E_PUBKEY_NOT_ALLOWED                                                 : return "Public key based protectors are not allowed on this drive";
    case FVE_E_VOLUME_HANDLE_OPEN                                                 : return "BitLocker Drive Encryption is already performing an operation on this drive. Please complete all operations before continuing";
    case FVE_E_NO_FEATURE_LICENSE                                                 : return "This version of Windows does not support this feature of BitLocker Drive Encryption. To use this feature, upgrade the operating system";
    case FVE_E_INVALID_STARTUP_OPTIONS                                            : return "The Group Policy settings for BitLocker startup options are in conflict and cannot be applied. Contact your system administrator for more information";
    case FVE_E_POLICY_RECOVERY_PASSWORD_NOT_ALLOWED                               : return "Group Policy settings do not permit the creation of a recovery password";
    case FVE_E_POLICY_RECOVERY_PASSWORD_REQUIRED                                  : return "Group Policy settings require the creation of a recovery password";
    case FVE_E_POLICY_RECOVERY_KEY_NOT_ALLOWED                                    : return "Group Policy settings do not permit the creation of a recovery key";
    case FVE_E_POLICY_RECOVERY_KEY_REQUIRED                                       : return "Group Policy settings require the creation of a recovery key";
    case FVE_E_POLICY_STARTUP_PIN_NOT_ALLOWED                                     : return "Group Policy settings do not permit the use of a PIN at startup. Please choose a different BitLocker startup option";
    case FVE_E_POLICY_STARTUP_PIN_REQUIRED                                        : return "Group Policy settings require the use of a PIN at startup. Please choose this BitLocker startup option";
    case FVE_E_POLICY_STARTUP_KEY_NOT_ALLOWED                                     : return "Group Policy settings do not permit the use of a startup key. Please choose a different BitLocker startup option";
    case FVE_E_POLICY_STARTUP_KEY_REQUIRED                                        : return "Group Policy settings require the use of a startup key. Please choose this BitLocker startup option";
    case FVE_E_POLICY_STARTUP_PIN_KEY_NOT_ALLOWED                                 : return "Group Policy settings do not permit the use of a startup key and PIN. Please choose a different BitLocker startup option";
    case FVE_E_POLICY_STARTUP_PIN_KEY_REQUIRED                                    : return "Group Policy settings require the use of a startup key and PIN. Please choose this BitLocker startup option";
    case FVE_E_POLICY_STARTUP_TPM_NOT_ALLOWED                                     : return "Group policy does not permit the use of TPM-only at startup. Please choose a different BitLocker startup option";
    case FVE_E_POLICY_STARTUP_TPM_REQUIRED                                        : return "Group Policy settings require the use of TPM-only at startup. Please choose this BitLocker startup option";
    case FVE_E_POLICY_INVALID_PIN_LENGTH                                          : return "The PIN provided does not meet minimum or maximum length requirements";
    case FVE_E_KEY_PROTECTOR_NOT_SUPPORTED                                        : return "The key protector is not supported by the version of BitLocker Drive Encryption currently on the drive. Upgrade the drive to add the key protector";
    case FVE_E_POLICY_PASSPHRASE_NOT_ALLOWED                                      : return "Group Policy settings do not permit the creation of a password";
    case FVE_E_POLICY_PASSPHRASE_REQUIRED                                         : return "Group Policy settings require the creation of a password";
    case FVE_E_FIPS_PREVENTS_PASSPHRASE                                           : return "The Group Policy setting requiring FIPS compliance prevents passwords from being generated or used. Please contact your system administrator for more information";
    case FVE_E_OS_VOLUME_PASSPHRASE_NOT_ALLOWED                                   : return "A password cannot be added to the operating system drive";
    case FVE_E_INVALID_BITLOCKER_OID                                              : return "The BitLocker object identifier (OID) on the drive appears to be invalid or corrupt. Use manage-BDE to reset the OID on this drive";
    case FVE_E_VOLUME_TOO_SMALL                                                   : return "The drive is too small to be protected using BitLocker Drive Encryption";
    case FVE_E_DV_NOT_SUPPORTED_ON_FS                                             : return "The selected discovery drive type is incompatible with the file system on the drive. BitLocker To Go discovery drives must be created on FAT formatted drives";
    case FVE_E_DV_NOT_ALLOWED_BY_GP                                               : return "The selected discovery drive type is not allowed by the computer's Group Policy settings. Verify that Group Policy settings allow the creation of discovery drives for use with BitLocker To Go";
    case FVE_E_POLICY_USER_CERTIFICATE_NOT_ALLOWED                                : return "Group Policy settings do not permit user certificates such as smart cards to be used with BitLocker Drive Encryption";
    case FVE_E_POLICY_USER_CERTIFICATE_REQUIRED                                   : return "Group Policy settings require that you have a valid user certificate, such as a smart card, to be used with BitLocker Drive Encryption";
    case FVE_E_POLICY_USER_CERT_MUST_BE_HW                                        : return "Group Policy settings requires that you use a smart card-based key protector with BitLocker Drive Encryption";
    case FVE_E_POLICY_USER_CONFIGURE_FDV_AUTOUNLOCK_NOT_ALLOWED                   : return "Group Policy settings do not permit BitLocker-protected fixed data drives to be automatically unlocked";
    case FVE_E_POLICY_USER_CONFIGURE_RDV_AUTOUNLOCK_NOT_ALLOWED                   : return "Group Policy settings do not permit BitLocker-protected removable data drives to be automatically unlocked";
    case FVE_E_POLICY_USER_CONFIGURE_RDV_NOT_ALLOWED                              : return "Group Policy settings do not permit you to configure BitLocker Drive Encryption on removable data drives";
    case FVE_E_POLICY_USER_ENABLE_RDV_NOT_ALLOWED                                 : return "Group Policy settings do not permit you to turn on BitLocker Drive Encryption on removable data drives. Please contact your system administrator if you need to turn on BitLocker";
    case FVE_E_POLICY_USER_DISABLE_RDV_NOT_ALLOWED                                : return "Group Policy settings do not permit turning off BitLocker Drive Encryption on removable data drives. Please contact your system administrator if you need to turn off BitLocker";
    case FVE_E_POLICY_INVALID_PASSPHRASE_LENGTH                                   : return "Your password does not meet minimum password length requirements. By default, passwords must be at least 8 characters in length. Check with your system administrator for the password length requirement in your organization";
    case FVE_E_POLICY_PASSPHRASE_TOO_SIMPLE                                       : return "Your password does not meet the complexity requirements set by your system administrator. Try adding upper and lowercase characters, numbers, and symbols";
    case FVE_E_RECOVERY_PARTITION                                                 : return "This drive cannot be encrypted because it is reserved for Windows System Recovery Options";
    case FVE_E_POLICY_CONFLICT_FDV_RK_OFF_AUK_ON                                  : return "BitLocker Drive Encryption cannot be applied to this drive because of conflicting Group Policy settings. BitLocker cannot be configured to automatically unlock fixed data drives when user recovery options are disabled. If you want BitLocker-protected fixed data drives to be automatically unlocked after key validation has occurred, please ask your system administrator to resolve the settings conflict before enabling BitLocker";
    case FVE_E_POLICY_CONFLICT_RDV_RK_OFF_AUK_ON                                  : return "BitLocker Drive Encryption cannot be applied to this drive because of conflicting Group Policy settings. BitLocker cannot be configured to automatically unlock removable data drives when user recovery option are disabled. If you want BitLocker-protected removable data drives to be automatically unlocked after key validation has occurred, please ask your system administrator to resolve the settings conflict before enabling BitLocker";
    case FVE_E_NON_BITLOCKER_OID                                                  : return "The Enhanced Key Usage (EKU) attribute of the specified certificate does not permit it to be used for BitLocker Drive Encryption. BitLocker does not require that a certificate have an EKU attribute, but if one is configured it must be set to an object identifier (OID) that matches the OID configured for BitLocker";
    case FVE_E_POLICY_PROHIBITS_SELFSIGNED                                        : return "BitLocker Drive Encryption cannot be applied to this drive as currently configured because of Group Policy settings. The certificate you provided for drive encryption is self-signed. Current Group Policy settings do not permit the use of self-signed certificates. Obtain a new certificate from your certification authority before attempting to enable BitLocker";
    case FVE_E_POLICY_CONFLICT_RO_AND_STARTUP_KEY_REQUIRED                        : return "BitLocker Encryption cannot be applied to this drive because of conflicting Group Policy settings. When write access to drives not protected by BitLocker is denied, the use of a USB startup key cannot be required. Please have your system administrator resolve these policy conflicts before attempting to enable BitLocker";
    case FVE_E_CONV_RECOVERY_FAILED                                               : return "BitLocker Drive Encryption failed to recover from an abruptly terminated conversion. This could be due to either all conversion logs being corrupted or the media being write-protected";
    case FVE_E_VIRTUALIZED_SPACE_TOO_BIG                                          : return "The requested virtualization size is too big";
    case FVE_E_POLICY_CONFLICT_OSV_RP_OFF_ADB_ON                                  : return "BitLocker Drive Encryption cannot be applied to this drive because there are conflicting Group Policy settings for recovery options on operating system drives. Storing recovery information to Active Directory Domain Services cannot be required when the generation of recovery passwords is not permitted. Please have your system administrator resolve these policy conflicts before attempting to enable BitLocker";
    case FVE_E_POLICY_CONFLICT_FDV_RP_OFF_ADB_ON                                  : return "BitLocker Drive Encryption cannot be applied to this drive because there are conflicting Group Policy settings for recovery options on fixed data drives. Storing recovery information to Active Directory Domain Services cannot be required when the generation of recovery passwords is not permitted. Please have your system administrator resolve these policy conflicts before attempting to enable BitLocker";
    case FVE_E_POLICY_CONFLICT_RDV_RP_OFF_ADB_ON                                  : return "BitLocker Drive Encryption cannot be applied to this drive because there are conflicting Group Policy settings for recovery options on removable data drives. Storing recovery information to Active Directory Domain Services cannot be required when the generation of recovery passwords is not permitted. Please have your system administrator resolve these policy conflicts before attempting to enable BitLocker";
    case FVE_E_NON_BITLOCKER_KU                                                   : return "The Key Usage (KU) attribute of the specified certificate does not permit it to be used for BitLocker Drive Encryption. BitLocker does not require that a certificate have a KU attribute, but if one is configured it must be set to either Key Encipherment or Key Agreement";
    case FVE_E_PRIVATEKEY_AUTH_FAILED                                             : return "The private key associated with the specified certificate cannot be authorized. The private key authorization was either not provided or the provided authorization was invalid";
    case FVE_E_REMOVAL_OF_DRA_FAILED                                              : return "Removal of the data recovery agent certificate must be done using the Certificates snap-in";
    case FVE_E_OPERATION_NOT_SUPPORTED_ON_VISTA_VOLUME                            : return "This drive was encrypted using the version of BitLocker Drive Encryption included with Windows Vista and Windows Server 2008 which does not support organizational identifiers. To specify organizational identifiers for this drive upgrade the drive encryption to the latest version using the \"manage-bde -upgrade\" command";
    case FVE_E_CANT_LOCK_AUTOUNLOCK_ENABLED_VOLUME                                : return "The drive cannot be locked because it is automatically unlocked on this computer.  Remove the automatic unlock protector to lock this drive";
    case FVE_E_FIPS_HASH_KDF_NOT_ALLOWED                                          : return "The default BitLocker Key Derivation Function SP800-56A for ECC smart cards is not supported by your smart card. The Group Policy setting requiring FIPS-compliance prevents BitLocker from using any other key derivation function for encryption. You have to use a FIPS compliant smart card in FIPS restricted environments";
    case FVE_E_ENH_PIN_INVALID                                                    : return "The BitLocker encryption key could not be obtained from the Trusted Platform Module (TPM) and enhanced PIN. Try using a PIN containing only numerals";
    case FVE_E_INVALID_PIN_CHARS                                                  : return "The requested TPM PIN contains invalid characters";
    case FVE_E_INVALID_DATUM_TYPE                                                 : return "The management information stored on the drive contained an unknown type. If you are using an old version of Windows, try accessing the drive from the latest version";
    case FVE_E_EFI_ONLY                                                           : return "The feature is only supported on EFI systems";
    case FVE_E_MULTIPLE_NKP_CERTS                                                 : return "More than one Network Key Protector certificate has been found on the system";
    case FVE_E_REMOVAL_OF_NKP_FAILED                                              : return "Removal of the Network Key Protector certificate must be done using the Certificates snap-in";
    case FVE_E_INVALID_NKP_CERT                                                   : return "An invalid certificate has been found in the Network Key Protector certificate store";
    case FVE_E_NO_EXISTING_PIN                                                    : return "This drive isn't protected with a PIN";
    case FVE_E_PROTECTOR_CHANGE_PIN_MISMATCH                                      : return "Please enter the correct current PIN";
    case FVE_E_PIN_PROTECTOR_CHANGE_BY_STD_USER_DISALLOWED                        : return "You must be logged on with an administrator account to change the PIN. Click the link to reset the PIN as an administrator";
    case FVE_E_PROTECTOR_CHANGE_MAX_PIN_CHANGE_ATTEMPTS_REACHED                   : return "BitLocker has disabled PIN changes after too many failed requests. Click the link to reset the PIN as an administrator";
    case FVE_E_POLICY_PASSPHRASE_REQUIRES_ASCII                                   : return "Your system administrator requires that passwords contain only printable ASCII characters. This includes unaccented letters (A-Z, a-z), numbers (0-9), space, arithmetic signs, common punctuation, separators, and the following symbols: # $ & @ ^ _ ~ ";
    case FVE_E_FULL_ENCRYPTION_NOT_ALLOWED_ON_TP_STORAGE                          : return "BitLocker Drive Encryption only supports Used Space Only encryption on thin provisioned storage";
    case FVE_E_WIPE_NOT_ALLOWED_ON_TP_STORAGE                                     : return "BitLocker Drive Encryption does not support wiping free space on thin provisioned storage";
    case FVE_E_KEY_LENGTH_NOT_SUPPORTED_BY_EDRIVE                                 : return "The required authentication key length is not supported by the drive";
    case FVE_E_NO_EXISTING_PASSPHRASE                                             : return "This drive isn't protected with a password";
    case FVE_E_PROTECTOR_CHANGE_PASSPHRASE_MISMATCH                               : return "Please enter the correct current password";
    case FVE_E_PASSPHRASE_TOO_LONG                                                : return "The password cannot exceed 256 characters";
    case FVE_E_NO_PASSPHRASE_WITH_TPM                                             : return "A password key protector cannot be added because a TPM protector exists on the drive";
    case FVE_E_NO_TPM_WITH_PASSPHRASE                                             : return "A TPM key protector cannot be added because a password protector exists on the drive";
    case FVE_E_NOT_ALLOWED_ON_CSV_STACK                                           : return "This command can only be performed from the coordinator node for the specified CSV volume";
    case FVE_E_NOT_ALLOWED_ON_CLUSTER                                             : return "This command cannot be performed on a volume when it is part of a cluster";
    case FVE_E_EDRIVE_NO_FAILOVER_TO_SW                                           : return "BitLocker did not revert to using BitLocker software encryption due to group policy configuration";
    case FVE_E_EDRIVE_BAND_IN_USE                                                 : return "The drive cannot be managed by BitLocker because the drive's hardware encryption feature is already in use";
    case FVE_E_EDRIVE_DISALLOWED_BY_GP                                            : return "Group Policy settings do not allow the use of hardware-based encryption";
    case FVE_E_EDRIVE_INCOMPATIBLE_VOLUME                                         : return "The drive specified does not support hardware-based encryption";
    case FVE_E_NOT_ALLOWED_TO_UPGRADE_WHILE_CONVERTING                            : return "BitLocker cannot be upgraded during disk encryption or decryption";
    case FVE_E_EDRIVE_DV_NOT_SUPPORTED                                            : return "Discovery Volumes are not supported for volumes using hardware encryption";
    case FVE_E_NO_PREBOOT_KEYBOARD_DETECTED                                       : return "No pre-boot keyboard detected. The user may not be able to provide required input to unlock the volume";
    case FVE_E_NO_PREBOOT_KEYBOARD_OR_WINRE_DETECTED                              : return "No pre-boot keyboard or Windows Recovery Environment detected. The user may not be able to provide required input to unlock the volume";
    case FVE_E_POLICY_REQUIRES_STARTUP_PIN_ON_TOUCH_DEVICE                        : return "Group Policy settings require the creation of a startup PIN, but a pre-boot keyboard is not available on this device. The user may not be able to provide required input to unlock the volume";
    case FVE_E_POLICY_REQUIRES_RECOVERY_PASSWORD_ON_TOUCH_DEVICE                  : return "Group Policy settings require the creation of a recovery password, but neither a pre-boot keyboard nor Windows Recovery Environment is available on this device. The user may not be able to provide required input to unlock the volume";
    case FVE_E_WIPE_CANCEL_NOT_APPLICABLE                                         : return "Wipe of free space is not currently taking place";
    case FVE_E_SECUREBOOT_DISABLED                                                : return "BitLocker cannot use Secure Boot for platform integrity because Secure Boot has been disabled";
    case FVE_E_SECUREBOOT_CONFIGURATION_INVALID                                   : return "BitLocker cannot use Secure Boot for platform integrity because the Secure Boot configuration does not meet the requirements for BitLocker";
    case FVE_E_EDRIVE_DRY_RUN_FAILED                                              : return "Your computer doesn't support BitLocker hardware-based encryption. Check with your computer manufacturer for firmware updates";
    case FVE_E_SHADOW_COPY_PRESENT                                                : return "BitLocker cannot be enabled on the volume because it contains a Volume Shadow Copy. Remove all Volume Shadow Copies before encrypting the volume";
    case FVE_E_POLICY_INVALID_ENHANCED_BCD_SETTINGS                               : return "BitLocker Drive Encryption cannot be applied to this drive because the Group Policy setting for Enhanced Boot Configuration Data contains invalid data. Please have your system administrator resolve this invalid configuration before attempting to enable BitLocker";
    case FVE_E_EDRIVE_INCOMPATIBLE_FIRMWARE                                       : return "This PC's firmware is not capable of supporting hardware encryption";
    case FVE_E_PROTECTOR_CHANGE_MAX_PASSPHRASE_CHANGE_ATTEMPTS_REACHED            : return "BitLocker has disabled password changes after too many failed requests. Click the link to reset the password as an administrator";
    case FVE_E_PASSPHRASE_PROTECTOR_CHANGE_BY_STD_USER_DISALLOWED                 : return "You must be logged on with an administrator account to change the password. Click the link to reset the password as an administrator";
    case FVE_E_LIVEID_ACCOUNT_SUSPENDED                                           : return "BitLocker cannot save the recovery password because the specified Microsoft account is Suspended";
    case FVE_E_LIVEID_ACCOUNT_BLOCKED                                             : return "BitLocker cannot save the recovery password because the specified Microsoft account is Blocked";
    case FVE_E_NOT_PROVISIONED_ON_ALL_VOLUMES                                     : return "This PC is not provisioned to support device encryption. Please enable BitLocker on all volumes to comply with device encryption policy";
    case FVE_E_DE_FIXED_DATA_NOT_SUPPORTED                                        : return "This PC cannot support device encryption because unencrypted fixed data volumes are present";
    case FVE_E_DE_HARDWARE_NOT_COMPLIANT                                          : return "This PC does not meet the hardware requirements to support device encryption";
    case FVE_E_DE_WINRE_NOT_CONFIGURED                                            : return "This PC cannot support device encryption because WinRE is not properly configured";
    case FVE_E_DE_PROTECTION_SUSPENDED                                            : return "Protection is enabled on the volume but has been suspended. This is likely to have happened due to an update being applied to your system. Please try again after a reboot";
    case FVE_E_DE_OS_VOLUME_NOT_PROTECTED                                         : return "This PC is not provisioned to support device encryption";
    case FVE_E_DE_DEVICE_LOCKEDOUT                                                : return "Device Lock has been triggered due to too many incorrect password attempts";
    case FVE_E_DE_PROTECTION_NOT_YET_ENABLED                                      : return "Protection has not been enabled on the volume. Enabling protection requires a connected account. If you already have a connected account and are seeing this error, please refer to the event log for more information";
    case FVE_E_INVALID_PIN_CHARS_DETAILED                                         : return "Your PIN can only contain numbers from 0 to 9";
    case FVE_E_DEVICE_LOCKOUT_COUNTER_UNAVAILABLE                                 : return "BitLocker cannot use hardware replay protection because no counter is available on your PC";
    case FVE_E_DEVICELOCKOUT_COUNTER_MISMATCH                                     : return "Device Lockout state validation failed due to counter mismatch";
    case FVE_E_BUFFER_TOO_LARGE                                                   : return "The input buffer is too large";
    case FVE_E_NO_SUCH_CAPABILITY_ON_TARGET                                       : return "The target of an invocation does not support requested capability";
    case FVE_E_DE_PREVENTED_FOR_OS                                                : return "Device encryption is currently blocked by this PC's configuration";
    case FVE_E_DE_VOLUME_OPTED_OUT                                                : return "This drive has been opted out of device encryption";
    case FVE_E_DE_VOLUME_NOT_SUPPORTED                                            : return "Device encryption isn't available for this drive";
    case FVE_E_EOW_NOT_SUPPORTED_IN_VERSION                                       : return "The encrypt on write mode for BitLocker is not supported in this version of Windows. You can turn on BitLocker without using the encrypt on write mode";
    case FVE_E_ADBACKUP_NOT_ENABLED                                               : return "Group policy prevents you from backing up your recovery password to Active Directory for this drive type. For more info, contact your system administrator";
    case FVE_E_VOLUME_EXTEND_PREVENTS_EOW_DECRYPT                                 : return "Device encryption can't be turned off while this drive is being encrypted. Please try again later";
    case FVE_E_NOT_DE_VOLUME                                                      : return "This action isn't supported because this drive isn't automatically managed with device encryption";
    case FVE_E_PROTECTION_CANNOT_BE_DISABLED                                      : return "BitLocker can't be suspended on this drive until the next restart";
    case FVE_E_OSV_KSR_NOT_ALLOWED                                                : return "BitLocker Drive Encryption policy does not allow KSR operation with protected OS volume";
    case FWP_E_CALLOUT_NOT_FOUND                                                  : return "The callout does not exist";
    case FWP_E_CONDITION_NOT_FOUND                                                : return "The filter condition does not exist";
    case FWP_E_FILTER_NOT_FOUND                                                   : return "The filter does not exist";
    case FWP_E_LAYER_NOT_FOUND                                                    : return "The layer does not exist";
    case FWP_E_PROVIDER_NOT_FOUND                                                 : return "The provider does not exist";
    case FWP_E_PROVIDER_CONTEXT_NOT_FOUND                                         : return "The provider context does not exist";
    case FWP_E_SUBLAYER_NOT_FOUND                                                 : return "The sublayer does not exist";
    case FWP_E_NOT_FOUND                                                          : return "The object does not exist";
    case FWP_E_ALREADY_EXISTS                                                     : return "An object with that GUID or LUID already exists";
    case FWP_E_IN_USE                                                             : return "The object is referenced by other objects so cannot be deleted";
    case FWP_E_DYNAMIC_SESSION_IN_PROGRESS                                        : return "The call is not allowed from within a dynamic session";
    case FWP_E_WRONG_SESSION                                                      : return "The call was made from the wrong session so cannot be completed";
    case FWP_E_NO_TXN_IN_PROGRESS                                                 : return "The call must be made from within an explicit transaction";
    case FWP_E_TXN_IN_PROGRESS                                                    : return "The call is not allowed from within an explicit transaction";
    case FWP_E_TXN_ABORTED                                                        : return "The explicit transaction has been forcibly cancelled";
    case FWP_E_SESSION_ABORTED                                                    : return "The session has been cancelled";
    case FWP_E_INCOMPATIBLE_TXN                                                   : return "The call is not allowed from within a read-only transaction";
    case FWP_E_TIMEOUT                                                            : return "The call timed out while waiting to acquire the transaction lock";
    case FWP_E_NET_EVENTS_DISABLED                                                : return "Collection of network diagnostic event is disabled";
    case FWP_E_INCOMPATIBLE_LAYER                                                 : return "The operation is not supported by the specified layer";
    case FWP_E_KM_CLIENTS_ONLY                                                    : return "The call is allowed for kernel-mode callers only";
    case FWP_E_LIFETIME_MISMATCH                                                  : return "The call tried to associate two objects with incompatible lifetimes";
    case FWP_E_BUILTIN_OBJECT                                                     : return "The object is built in so cannot be deleted";
    case FWP_E_TOO_MANY_CALLOUTS                                                  : return "The maximum number of callouts has been reached";
    case FWP_E_NOTIFICATION_DROPPED                                               : return "A notification could not be delivered because a message queue is at its maximum capacity";
    case FWP_E_TRAFFIC_MISMATCH                                                   : return "The traffic parameters do not match those for the security association context";
    case FWP_E_INCOMPATIBLE_SA_STATE                                              : return "The call is not allowed for the current security association state";
    case FWP_E_NULL_POINTER                                                       : return "A required pointer is null";
    case FWP_E_INVALID_ENUMERATOR                                                 : return "An enumerator is not valid";
    case FWP_E_INVALID_FLAGS                                                      : return "The flags field contains an invalid value";
    case FWP_E_INVALID_NET_MASK                                                   : return "A network mask is not valid";
    case FWP_E_INVALID_RANGE                                                      : return "An FWP_RANGE is not valid";
    case FWP_E_INVALID_INTERVAL                                                   : return "The time interval is not valid";
    case FWP_E_ZERO_LENGTH_ARRAY                                                  : return "An array that must contain at least one element is zero length";
    case FWP_E_NULL_DISPLAY_NAME                                                  : return "The displayData.name field cannot be null";
    case FWP_E_INVALID_ACTION_TYPE                                                : return "The action type is not one of the allowed action types for a filter";
    case FWP_E_INVALID_WEIGHT                                                     : return "The filter weight is not valid";
    case FWP_E_MATCH_TYPE_MISMATCH                                                : return "A filter condition contains a match type that is not compatible with the operands";
    case FWP_E_TYPE_MISMATCH                                                      : return "An FWP_VALUE or FWPM_CONDITION_VALUE is of the wrong type";
    case FWP_E_OUT_OF_BOUNDS                                                      : return "An integer value is outside the allowed range";
    case FWP_E_RESERVED                                                           : return "A reserved field is non-zero";
    case FWP_E_DUPLICATE_CONDITION                                                : return "A filter cannot contain multiple conditions operating on a single field";
    case FWP_E_DUPLICATE_KEYMOD                                                   : return "A policy cannot contain the same keying module more than once";
    case FWP_E_ACTION_INCOMPATIBLE_WITH_LAYER                                     : return "The action type is not compatible with the layer";
    case FWP_E_ACTION_INCOMPATIBLE_WITH_SUBLAYER                                  : return "The action type is not compatible with the sublayer";
    case FWP_E_CONTEXT_INCOMPATIBLE_WITH_LAYER                                    : return "The raw context or the provider context is not compatible with the layer";
    case FWP_E_CONTEXT_INCOMPATIBLE_WITH_CALLOUT                                  : return "The raw context or the provider context is not compatible with the callout";
    case FWP_E_INCOMPATIBLE_AUTH_METHOD                                           : return "The authentication method is not compatible with the policy type";
    case FWP_E_INCOMPATIBLE_DH_GROUP                                              : return "The Diffie-Hellman group is not compatible with the policy type";
    case FWP_E_EM_NOT_SUPPORTED                                                   : return "An IKE policy cannot contain an Extended Mode policy";
    case FWP_E_NEVER_MATCH                                                        : return "The enumeration template or subscription will never match any objects";
    case FWP_E_PROVIDER_CONTEXT_MISMATCH                                          : return "The provider context is of the wrong type";
    case FWP_E_INVALID_PARAMETER                                                  : return "The parameter is incorrect";
    case FWP_E_TOO_MANY_SUBLAYERS                                                 : return "The maximum number of sublayers has been reached";
    case FWP_E_CALLOUT_NOTIFICATION_FAILED                                        : return "The notification function for a callout returned an error";
    case FWP_E_INVALID_AUTH_TRANSFORM                                             : return "The IPsec authentication transform is not valid";
    case FWP_E_INVALID_CIPHER_TRANSFORM                                           : return "The IPsec cipher transform is not valid";
    case FWP_E_INCOMPATIBLE_CIPHER_TRANSFORM                                      : return "The IPsec cipher transform is not compatible with the policy";
    case FWP_E_INVALID_TRANSFORM_COMBINATION                                      : return "The combination of IPsec transform types is not valid";
    case FWP_E_DUPLICATE_AUTH_METHOD                                              : return "A policy cannot contain the same auth method more than once";
    case FWP_E_INVALID_TUNNEL_ENDPOINT                                            : return "A tunnel endpoint configuration is invalid";
    case FWP_E_L2_DRIVER_NOT_READY                                                : return "The WFP MAC Layers are not ready";
    case FWP_E_KEY_DICTATOR_ALREADY_REGISTERED                                    : return "A key manager capable of key dictation is already registered";
    case FWP_E_KEY_DICTATION_INVALID_KEYING_MATERIAL                              : return "A key manager dictated invalid keys";
    case FWP_E_CONNECTIONS_DISABLED                                               : return "The BFE IPsec Connection Tracking is disabled";
    case FWP_E_INVALID_DNS_NAME                                                   : return "The DNS name is invalid";
    case FWP_E_STILL_ON                                                           : return "The engine option is still enabled due to other configuration settings";
    case FWP_E_IKEEXT_NOT_RUNNING                                                 : return "The IKEEXT service is not running.  This service only runs when there is IPsec policy applied to the machine";
    case FWP_E_DROP_NOICMP                                                        : return "The packet should be dropped, no ICMP should be sent";
    case WS_S_ASYNC                                                               : return "The function call is completing asynchronously";
    case WS_S_END                                                                 : return "There are no more messages available on the channel";
    case WS_E_INVALID_FORMAT                                                      : return "The input data was not in the expected format or did not have the expected value";
    case WS_E_OBJECT_FAULTED                                                      : return "The operation could not be completed because the object is in a faulted state due to a previous error";
    case WS_E_NUMERIC_OVERFLOW                                                    : return "The operation could not be completed because it would lead to numeric overflow";
    case WS_E_INVALID_OPERATION                                                   : return "The operation is not allowed due to the current state of the object";
    case WS_E_OPERATION_ABORTED                                                   : return "The operation was aborted";
    case WS_E_ENDPOINT_ACCESS_DENIED                                              : return "Access was denied by the remote endpoint";
    case WS_E_OPERATION_TIMED_OUT                                                 : return "The operation did not complete within the time allotted";
    case WS_E_OPERATION_ABANDONED                                                 : return "The operation was abandoned";
    case WS_E_QUOTA_EXCEEDED                                                      : return "A quota was exceeded";
    case WS_E_NO_TRANSLATION_AVAILABLE                                            : return "The information was not available in the specified language";
    case WS_E_SECURITY_VERIFICATION_FAILURE                                       : return "Security verification was not successful for the received data";
    case WS_E_ADDRESS_IN_USE                                                      : return "The address is already being used";
    case WS_E_ADDRESS_NOT_AVAILABLE                                               : return "The address is not valid for this context";
    case WS_E_ENDPOINT_NOT_FOUND                                                  : return "The remote endpoint does not exist or could not be located";
    case WS_E_ENDPOINT_NOT_AVAILABLE                                              : return "The remote endpoint is not currently in service at this location";
    case WS_E_ENDPOINT_FAILURE                                                    : return "The remote endpoint could not process the request";
    case WS_E_ENDPOINT_UNREACHABLE                                                : return "The remote endpoint was not reachable";
    case WS_E_ENDPOINT_ACTION_NOT_SUPPORTED                                       : return "The operation was not supported by the remote endpoint";
    case WS_E_ENDPOINT_TOO_BUSY                                                   : return "The remote endpoint is unable to process the request due to being overloaded";
    case WS_E_ENDPOINT_FAULT_RECEIVED                                             : return "A message containing a fault was received from the remote endpoint";
    case WS_E_ENDPOINT_DISCONNECTED                                               : return "The connection with the remote endpoint was terminated";
    case WS_E_PROXY_FAILURE                                                       : return "The HTTP proxy server could not process the request";
    case WS_E_PROXY_ACCESS_DENIED                                                 : return "Access was denied by the HTTP proxy server";
    case WS_E_NOT_SUPPORTED                                                       : return "The requested feature is not available on this platform";
    case WS_E_PROXY_REQUIRES_BASIC_AUTH                                           : return "The HTTP proxy server requires HTTP authentication scheme 'basic'";
    case WS_E_PROXY_REQUIRES_DIGEST_AUTH                                          : return "The HTTP proxy server requires HTTP authentication scheme 'digest'";
    case WS_E_PROXY_REQUIRES_NTLM_AUTH                                            : return "The HTTP proxy server requires HTTP authentication scheme 'NTLM'";
    case WS_E_PROXY_REQUIRES_NEGOTIATE_AUTH                                       : return "The HTTP proxy server requires HTTP authentication scheme 'negotiate'";
    case WS_E_SERVER_REQUIRES_BASIC_AUTH                                          : return "The remote endpoint requires HTTP authentication scheme 'basic'";
    case WS_E_SERVER_REQUIRES_DIGEST_AUTH                                         : return "The remote endpoint requires HTTP authentication scheme 'digest'";
    case WS_E_SERVER_REQUIRES_NTLM_AUTH                                           : return "The remote endpoint requires HTTP authentication scheme 'NTLM'";
    case WS_E_SERVER_REQUIRES_NEGOTIATE_AUTH                                      : return "The remote endpoint requires HTTP authentication scheme 'negotiate'";
    case WS_E_INVALID_ENDPOINT_URL                                                : return "The endpoint address URL is invalid";
    case WS_E_OTHER                                                               : return "Unrecognized error occurred in the Windows Web Services framework";
    case WS_E_SECURITY_TOKEN_EXPIRED                                              : return "A security token was rejected by the server because it has expired";
    case WS_E_SECURITY_SYSTEM_FAILURE                                             : return "A security operation failed in the Windows Web Services framework";
    case ERROR_NDIS_INTERFACE_CLOSING                                             : return "The binding to the network interface is being closed";
    case ERROR_NDIS_BAD_VERSION                                                   : return "An invalid version was specified";
    case ERROR_NDIS_BAD_CHARACTERISTICS                                           : return "An invalid characteristics table was used";
    case ERROR_NDIS_ADAPTER_NOT_FOUND                                             : return "Failed to find the network interface or network interface is not ready";
    case ERROR_NDIS_OPEN_FAILED                                                   : return "Failed to open the network interface";
    case ERROR_NDIS_DEVICE_FAILED                                                 : return "Network interface has encountered an internal unrecoverable failure";
    case ERROR_NDIS_MULTICAST_FULL                                                : return "The multicast list on the network interface is full";
    case ERROR_NDIS_MULTICAST_EXISTS                                              : return "An attempt was made to add a duplicate multicast address to the list";
    case ERROR_NDIS_MULTICAST_NOT_FOUND                                           : return "At attempt was made to remove a multicast address that was never added";
    case ERROR_NDIS_REQUEST_ABORTED                                               : return "Netowork interface aborted the request";
    case ERROR_NDIS_RESET_IN_PROGRESS                                             : return "Network interface can not process the request because it is being reset";
    case ERROR_NDIS_NOT_SUPPORTED                                                 : return "Netword interface does not support this request";
    case ERROR_NDIS_INVALID_PACKET                                                : return "An attempt was made to send an invalid packet on a network interface";
    case ERROR_NDIS_ADAPTER_NOT_READY                                             : return "Network interface is not ready to complete this operation";
    case ERROR_NDIS_INVALID_LENGTH                                                : return "The length of the buffer submitted for this operation is not valid";
    case ERROR_NDIS_INVALID_DATA                                                  : return "The data used for this operation is not valid";
    case ERROR_NDIS_BUFFER_TOO_SHORT                                              : return "The length of buffer submitted for this operation is too small";
    case ERROR_NDIS_INVALID_OID                                                   : return "Network interface does not support this OID (Object Identifier)";
    case ERROR_NDIS_ADAPTER_REMOVED                                               : return "The network interface has been removed";
    case ERROR_NDIS_UNSUPPORTED_MEDIA                                             : return "Network interface does not support this media type";
    case ERROR_NDIS_GROUP_ADDRESS_IN_USE                                          : return "An attempt was made to remove a token ring group address that is in use by other components";
    case ERROR_NDIS_FILE_NOT_FOUND                                                : return "An attempt was made to map a file that can not be found";
    case ERROR_NDIS_ERROR_READING_FILE                                            : return "An error occurred while NDIS tried to map the file";
    case ERROR_NDIS_ALREADY_MAPPED                                                : return "An attempt was made to map a file that is alreay mapped";
    case ERROR_NDIS_RESOURCE_CONFLICT                                             : return "An attempt to allocate a hardware resource failed because the resource is used by another component";
    case ERROR_NDIS_MEDIA_DISCONNECTED                                            : return "The I/O operation failed because network media is disconnected or wireless access point is out of range";
    case ERROR_NDIS_INVALID_ADDRESS                                               : return "The network address used in the request is invalid";
    case ERROR_NDIS_INVALID_DEVICE_REQUEST                                        : return "The specified request is not a valid operation for the target device";
    case ERROR_NDIS_PAUSED                                                        : return "The offload operation on the network interface has been paused";
    case ERROR_NDIS_INTERFACE_NOT_FOUND                                           : return "Network interface was not found";
    case ERROR_NDIS_UNSUPPORTED_REVISION                                          : return "The revision number specified in the structure is not supported";
    case ERROR_NDIS_INVALID_PORT                                                  : return "The specified port does not exist on this network interface";
    case ERROR_NDIS_INVALID_PORT_STATE                                            : return "The current state of the specified port on this network interface does not support the requested operation";
    case ERROR_NDIS_LOW_POWER_STATE                                               : return "The miniport adapter is in low power state";
    case ERROR_NDIS_REINIT_REQUIRED                                               : return "This operation requires the miniport adapter to be reinitialized";
    case ERROR_NDIS_DOT11_AUTO_CONFIG_ENABLED                                     : return "The wireless local area network interface is in auto configuration mode and doesn't support the requested parameter change operation";
    case ERROR_NDIS_DOT11_MEDIA_IN_USE                                            : return "The wireless local area network interface is busy and can not perform the requested operation";
    case ERROR_NDIS_DOT11_POWER_STATE_INVALID                                     : return "The wireless local area network interface is powered down and doesn't support the requested operation";
    case ERROR_NDIS_PM_WOL_PATTERN_LIST_FULL                                      : return "The list of wake on LAN patterns is full";
    case ERROR_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL                                 : return "The list of low power protocol offloads is full";
    case ERROR_NDIS_DOT11_AP_CHANNEL_CURRENTLY_NOT_AVAILABLE                      : return "The wireless local area network interface cannot start an AP on the specified channel right now";
    case ERROR_NDIS_DOT11_AP_BAND_CURRENTLY_NOT_AVAILABLE                         : return "The wireless local area network interface cannot start an AP on the specified band right now";
    case ERROR_NDIS_DOT11_AP_CHANNEL_NOT_ALLOWED                                  : return "The wireless local area network interface cannot start an AP on this channel due to regulatory reasons";
    case ERROR_NDIS_DOT11_AP_BAND_NOT_ALLOWED                                     : return "The wireless local area network interface cannot start an AP on this band due to regulatory reasons";
    case ERROR_NDIS_INDICATION_REQUIRED                                           : return "The request will be completed later by NDIS status indication";
    case ERROR_NDIS_OFFLOAD_POLICY                                                : return "The TCP connection is not offloadable because of a local policy setting";
    case ERROR_NDIS_OFFLOAD_CONNECTION_REJECTED                                   : return "The TCP connection is not offloadable by the Chimney Offload target";
    case ERROR_NDIS_OFFLOAD_PATH_REJECTED                                         : return "The IP Path object is not in an offloadable state";
    case ERROR_HV_INVALID_HYPERCALL_CODE                                          : return "The hypervisor does not support the operation because the specified hypercall code is not supported";
    case ERROR_HV_INVALID_HYPERCALL_INPUT                                         : return "The hypervisor does not support the operation because the encoding for the hypercall input register is not supported";
    case ERROR_HV_INVALID_ALIGNMENT                                               : return "The hypervisor could not perform the operation because a parameter has an invalid alignment";
    case ERROR_HV_INVALID_PARAMETER                                               : return "The hypervisor could not perform the operation because an invalid parameter was specified";
    case ERROR_HV_ACCESS_DENIED                                                   : return "Access to the specified object was denied";
    case ERROR_HV_INVALID_PARTITION_STATE                                         : return "The hypervisor could not perform the operation because the partition is entering or in an invalid state";
    case ERROR_HV_OPERATION_DENIED                                                : return "The operation is not allowed in the current state";
    case ERROR_HV_UNKNOWN_PROPERTY                                                : return "The hypervisor does not recognize the specified partition property";
    case ERROR_HV_PROPERTY_VALUE_OUT_OF_RANGE                                     : return "The specified value of a partition property is out of range or violates an invariant";
    case ERROR_HV_INSUFFICIENT_MEMORY                                             : return "There is not enough memory in the hypervisor pool to complete the operation";
    case ERROR_HV_PARTITION_TOO_DEEP                                              : return "The maximum partition depth has been exceeded for the partition hierarchy";
    case ERROR_HV_INVALID_PARTITION_ID                                            : return "A partition with the specified partition Id does not exist";
    case ERROR_HV_INVALID_VP_INDEX                                                : return "The hypervisor could not perform the operation because the specified VP index is invalid";
    case ERROR_HV_INVALID_PORT_ID                                                 : return "The hypervisor could not perform the operation because the specified port identifier is invalid";
    case ERROR_HV_INVALID_CONNECTION_ID                                           : return "The hypervisor could not perform the operation because the specified connection identifier is invalid";
    case ERROR_HV_INSUFFICIENT_BUFFERS                                            : return "Not enough buffers were supplied to send a message";
    case ERROR_HV_NOT_ACKNOWLEDGED                                                : return "The previous virtual interrupt has not been acknowledged";
    case ERROR_HV_INVALID_VP_STATE                                                : return "A virtual processor is not in the correct state for the indicated operation";
    case ERROR_HV_ACKNOWLEDGED                                                    : return "The previous virtual interrupt has already been acknowledged";
    case ERROR_HV_INVALID_SAVE_RESTORE_STATE                                      : return "The indicated partition is not in a valid state for saving or restoring";
    case ERROR_HV_INVALID_SYNIC_STATE                                             : return "The hypervisor could not complete the operation because a required feature of the synthetic interrupt controller (SynIC) was disabled";
    case ERROR_HV_OBJECT_IN_USE                                                   : return "The hypervisor could not perform the operation because the object or value was either already in use or being used for a purpose that would not permit completing the operation";
    case ERROR_HV_INVALID_PROXIMITY_DOMAIN_INFO                                   : return "The proximity domain information is invalid";
    case ERROR_HV_NO_DATA                                                         : return "An attempt to retrieve debugging data failed because none was available";
    case ERROR_HV_INACTIVE                                                        : return "The physical connection being used for debuggging has not recorded any receive activity since the last operation";
    case ERROR_HV_NO_RESOURCES                                                    : return "There are not enough resources to complete the operation";
    case ERROR_HV_FEATURE_UNAVAILABLE                                             : return "A hypervisor feature is not available to the user";
    case ERROR_HV_INSUFFICIENT_BUFFER                                             : return "The specified buffer was too small to contain all of the requested data";
    case ERROR_HV_INSUFFICIENT_DEVICE_DOMAINS                                     : return "The maximum number of domains supported by the platform I/O remapping hardware is currently in use. No domains are available to assign this device to this partition";
    case ERROR_HV_CPUID_FEATURE_VALIDATION                                        : return "Validation of CPUID data of the processor failed";
    case ERROR_HV_CPUID_XSAVE_FEATURE_VALIDATION                                  : return "Validation of XSAVE CPUID data of the processor failed";
    case ERROR_HV_PROCESSOR_STARTUP_TIMEOUT                                       : return "Processor did not respond within the timeout period";
    case ERROR_HV_SMX_ENABLED                                                     : return "SMX has been enabled in the BIOS";
    case ERROR_HV_INVALID_LP_INDEX                                                : return "The hypervisor could not perform the operation because the specified LP index is invalid";
    case ERROR_HV_INVALID_REGISTER_VALUE                                          : return "The supplied register value is invalid";
    case ERROR_HV_INVALID_VTL_STATE                                               : return "The supplied virtual trust level is not in the correct state to perform the requested operation";
    case ERROR_HV_NX_NOT_DETECTED                                                 : return "No execute feature (NX) is not present or not enabled in the BIOS";
    case ERROR_HV_INVALID_DEVICE_ID                                               : return "The supplied device ID is invalid";
    case ERROR_HV_INVALID_DEVICE_STATE                                            : return "The operation is not allowed in the current device state";
    case ERROR_HV_PENDING_PAGE_REQUESTS                                           : return "The device had pending page requests which were discarded";
    case ERROR_HV_PAGE_REQUEST_INVALID                                            : return "The supplied page request specifies a memory access that the guest does not have permissions to perform";
    case ERROR_HV_INVALID_CPU_GROUP_ID                                            : return "A CPU group with the specified CPU group Id does not exist";
    case ERROR_HV_INVALID_CPU_GROUP_STATE                                         : return "The hypervisor could not perform the operation because the CPU group is entering or in an invalid state";
    case ERROR_HV_OPERATION_FAILED                                                : return "The requested operation failed";
    case ERROR_HV_NOT_ALLOWED_WITH_NESTED_VIRT_ACTIVE                             : return "The hypervisor could not perform the operation because it is not allowed with nested virtualization active";
    case ERROR_HV_NOT_PRESENT                                                     : return "No hypervisor is present on this system";
    case ERROR_VID_DUPLICATE_HANDLER                                              : return "The handler for the virtualization infrastructure driver is already registered. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_TOO_MANY_HANDLERS                                              : return "The number of registered handlers for the virtualization infrastructure driver exceeded the maximum. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_QUEUE_FULL                                                     : return "The message queue for the virtualization infrastructure driver is full and cannot accept new messages. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_HANDLER_NOT_PRESENT                                            : return "No handler exists to handle the message for the virtualization infrastructure driver. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_INVALID_OBJECT_NAME                                            : return "The name of the partition or message queue for the virtualization infrastructure driver is invalid. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_PARTITION_NAME_TOO_LONG                                        : return "The partition name of the virtualization infrastructure driver exceeds the maximum";
    case ERROR_VID_MESSAGE_QUEUE_NAME_TOO_LONG                                    : return "The message queue name of the virtualization infrastructure driver exceeds the maximum";
    case ERROR_VID_PARTITION_ALREADY_EXISTS                                       : return "Cannot create the partition for the virtualization infrastructure driver because another partition with the same name already exists";
    case ERROR_VID_PARTITION_DOES_NOT_EXIST                                       : return "The virtualization infrastructure driver has encountered an error. The requested partition does not exist. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_PARTITION_NAME_NOT_FOUND                                       : return "The virtualization infrastructure driver has encountered an error. Could not find the requested partition. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_MESSAGE_QUEUE_ALREADY_EXISTS                                   : return "A message queue with the same name already exists for the virtualization infrastructure driver";
    case ERROR_VID_EXCEEDED_MBP_ENTRY_MAP_LIMIT                                   : return "The memory block page for the virtualization infrastructure driver cannot be mapped because the page map limit has been reached. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_MB_STILL_REFERENCED                                            : return "The memory block for the virtualization infrastructure driver is still being used and cannot be destroyed";
    case ERROR_VID_CHILD_GPA_PAGE_SET_CORRUPTED                                   : return "Cannot unlock the page array for the guest operating system memory address because it does not match a previous lock request. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_INVALID_NUMA_SETTINGS                                          : return "The non-uniform memory access (NUMA) node settings do not match the system NUMA topology. In order to start the virtual machine, you will need to modify the NUMA configuration";
    case ERROR_VID_INVALID_NUMA_NODE_INDEX                                        : return "The non-uniform memory access (NUMA) node index does not match a valid index in the system NUMA topology";
    case ERROR_VID_NOTIFICATION_QUEUE_ALREADY_ASSOCIATED                          : return "The memory block for the virtualization infrastructure driver is already associated with a message queue";
    case ERROR_VID_INVALID_MEMORY_BLOCK_HANDLE                                    : return "The handle is not a valid memory block handle for the virtualization infrastructure driver";
    case ERROR_VID_PAGE_RANGE_OVERFLOW                                            : return "The request exceeded the memory block page limit for the virtualization infrastructure driver. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_INVALID_MESSAGE_QUEUE_HANDLE                                   : return "The handle is not a valid message queue handle for the virtualization infrastructure driver";
    case ERROR_VID_INVALID_GPA_RANGE_HANDLE                                       : return "The handle is not a valid page range handle for the virtualization infrastructure driver";
    case ERROR_VID_NO_MEMORY_BLOCK_NOTIFICATION_QUEUE                             : return "Cannot install client notifications because no message queue for the virtualization infrastructure driver is associated with the memory block";
    case ERROR_VID_MEMORY_BLOCK_LOCK_COUNT_EXCEEDED                               : return "The request to lock or map a memory block page failed because the virtualization infrastructure driver memory block limit has been reached. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_INVALID_PPM_HANDLE                                             : return "The handle is not a valid parent partition mapping handle for the virtualization infrastructure driver";
    case ERROR_VID_MBPS_ARE_LOCKED                                                : return "Notifications cannot be created on the memory block because it is use";
    case ERROR_VID_MESSAGE_QUEUE_CLOSED                                           : return "The message queue for the virtualization infrastructure driver has been closed. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_VIRTUAL_PROCESSOR_LIMIT_EXCEEDED                               : return "Cannot add a virtual processor to the partition because the maximum has been reached";
    case ERROR_VID_STOP_PENDING                                                   : return "Cannot stop the virtual processor immediately because of a pending intercept";
    case ERROR_VID_INVALID_PROCESSOR_STATE                                        : return "Invalid state for the virtual processor. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_EXCEEDED_KM_CONTEXT_COUNT_LIMIT                                : return "The maximum number of kernel mode clients for the virtualization infrastructure driver has been reached. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_KM_INTERFACE_ALREADY_INITIALIZED                               : return "This kernel mode interface for the virtualization infrastructure driver has already been initialized. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_MB_PROPERTY_ALREADY_SET_RESET                                  : return "Cannot set or reset the memory block property more than once for the virtualization infrastructure driver. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_MMIO_RANGE_DESTROYED                                           : return "The memory mapped I/O for this page range no longer exists. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_INVALID_CHILD_GPA_PAGE_SET                                     : return "The lock or unlock request uses an invalid guest operating system memory address. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_RESERVE_PAGE_SET_IS_BEING_USED                                 : return "Cannot destroy or reuse the reserve page set for the virtualization infrastructure driver because it is in use. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_RESERVE_PAGE_SET_TOO_SMALL                                     : return "The reserve page set for the virtualization infrastructure driver is too small to use in the lock request. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_MBP_ALREADY_LOCKED_USING_RESERVED_PAGE                         : return "Cannot lock or map the memory block page for the virtualization infrastructure driver because it has already been locked using a reserve page set page. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_MBP_COUNT_EXCEEDED_LIMIT                                       : return "Cannot create the memory block for the virtualization infrastructure driver because the requested number of pages exceeded the limit. Restarting the virtual machine may fix the problem. If the problem persists, try restarting the physical computer";
    case ERROR_VID_SAVED_STATE_CORRUPT                                            : return "Cannot restore this virtual machine because the saved state data cannot be read. Delete the saved state data and then try to start the virtual machine";
    case ERROR_VID_SAVED_STATE_UNRECOGNIZED_ITEM                                  : return "Cannot restore this virtual machine because an item read from the saved state data is not recognized. Delete the saved state data and then try to start the virtual machine";
    case ERROR_VID_SAVED_STATE_INCOMPATIBLE                                       : return "Cannot restore this virtual machine to the saved state because of hypervisor incompatibility. Delete the saved state data and then try to start the virtual machine";
    case ERROR_VID_VTL_ACCESS_DENIED                                              : return "The specified VTL does not have the permission to access the resource";
    case ERROR_VMCOMPUTE_TERMINATED_DURING_START                                  : return "The compute system unexpectedly terminated while starting";
    case ERROR_VMCOMPUTE_IMAGE_MISMATCH                                           : return "The operating system of the container does not match the operating system of the host";
    case ERROR_VMCOMPUTE_HYPERV_NOT_INSTALLED                                     : return "A Virtual Machine could not be started because Hyper-V is not installed";
    case ERROR_VMCOMPUTE_OPERATION_PENDING                                        : return "The call to start an asynchronous operation succeeded and the operation is performed in the background";
    case ERROR_VMCOMPUTE_TOO_MANY_NOTIFICATIONS                                   : return "The supported number of notification callbacks has been exceeded";
    case ERROR_VMCOMPUTE_INVALID_STATE                                            : return "The requested compute system operation is not valid in the current state";
    case ERROR_VMCOMPUTE_UNEXPECTED_EXIT                                          : return "The compute system exited unexpectedly";
    case ERROR_VMCOMPUTE_TERMINATED                                               : return "The compute system was forcefully terminated";
    case ERROR_VMCOMPUTE_CONNECT_FAILED                                           : return "A connection could not be established with the Virtual Machine hosting the Container";
    case ERROR_VMCOMPUTE_TIMEOUT                                                  : return "The operation timed out because a response was not received from the Virtual Machine hosting the Container";
    case ERROR_VMCOMPUTE_CONNECTION_CLOSED                                        : return "The connection with the Virtual Machine hosting the container was closed";
    case ERROR_VMCOMPUTE_UNKNOWN_MESSAGE                                          : return "An unknown internal message was received by the Hyper-V Compute Service";
    case ERROR_VMCOMPUTE_UNSUPPORTED_PROTOCOL_VERSION                             : return "The communication protocol version between the Hyper-V Host and Guest Compute Services is not supported";
    case ERROR_VMCOMPUTE_INVALID_JSON                                             : return "The JSON document is invalid";
    case ERROR_VMCOMPUTE_SYSTEM_NOT_FOUND                                         : return "A Compute System with the specified identifier does not exist";
    case ERROR_VMCOMPUTE_SYSTEM_ALREADY_EXISTS                                    : return "A Compute System with the specified identifier already exists";
    case ERROR_VMCOMPUTE_SYSTEM_ALREADY_STOPPED                                   : return "The Compute System with the specified identifier did already stop";
    case ERROR_VMCOMPUTE_PROTOCOL_ERROR                                           : return "A communication protocol error has occurred between the Hyper-V Host and Guest Compute Service";
    case ERROR_VMCOMPUTE_INVALID_LAYER                                            : return "The container's image contains a layer with an unrecognized format";
    case ERROR_VMCOMPUTE_WINDOWS_INSIDER_REQUIRED                                 : return "To use this container image, you must join the Windows Insider Program. Please see https://go.microsoft.com/fwlink/?linkid=850659 for more information";
    case ERROR_VNET_VIRTUAL_SWITCH_NAME_NOT_FOUND                                 : return "A virtual switch with the given name was not found";
    case ERROR_VID_REMOTE_NODE_PARENT_GPA_PAGES_USED                              : return "A virtual machine is running with its memory allocated across multiple NUMA nodes. This does not indicate a problem unless the performance of your virtual machine is unusually slow. If you are experiencing performance problems, you may need to modify the NUMA configuration";
    case WHV_E_UNKNOWN_CAPABILITY                                                 : return "The specified capability does not exist";
    case WHV_E_INSUFFICIENT_BUFFER                                                : return "The specified buffer is too small for the requested data";
    case WHV_E_UNKNOWN_PROPERTY                                                   : return "The specified property does not exist";
    case WHV_E_UNSUPPORTED_HYPERVISOR_CONFIG                                      : return "The configuration of the hypervisor on this system is not supported";
    case WHV_E_INVALID_PARTITION_CONFIG                                           : return "The configuration of the partition is not valid";
    case WHV_E_GPA_RANGE_NOT_FOUND                                                : return "The specified GPA range was not found";
    case WHV_E_VP_ALREADY_EXISTS                                                  : return "A virtual processor with the specified index already exists";
    case WHV_E_VP_DOES_NOT_EXIST                                                  : return "A virtual processor with the specified index does not exist";
    case WHV_E_INVALID_VP_STATE                                                   : return "The virtual processor is not in the correct state to perform the requested operation";
    case WHV_E_INVALID_VP_REGISTER_NAME                                           : return "A virtual processor register with the specified name does not exist";
    case ERROR_VOLMGR_INCOMPLETE_REGENERATION                                     : return "The regeneration operation was not able to copy all data from the active plexes due to bad sectors";
    case ERROR_VOLMGR_INCOMPLETE_DISK_MIGRATION                                   : return "One or more disks were not fully migrated to the target pack. They may or may not require reimport after fixing the hardware problems";
    case ERROR_VOLMGR_DATABASE_FULL                                               : return "The configuration database is full";
    case ERROR_VOLMGR_DISK_CONFIGURATION_CORRUPTED                                : return "The configuration data on the disk is corrupted";
    case ERROR_VOLMGR_DISK_CONFIGURATION_NOT_IN_SYNC                              : return "The configuration on the disk is not insync with the in-memory configuration";
    case ERROR_VOLMGR_PACK_CONFIG_UPDATE_FAILED                                   : return "A majority of disks failed to be updated with the new configuration";
    case ERROR_VOLMGR_DISK_CONTAINS_NON_SIMPLE_VOLUME                             : return "The disk contains non-simple volumes";
    case ERROR_VOLMGR_DISK_DUPLICATE                                              : return "The same disk was specified more than once in the migration list";
    case ERROR_VOLMGR_DISK_DYNAMIC                                                : return "The disk is already dynamic";
    case ERROR_VOLMGR_DISK_ID_INVALID                                             : return "The specified disk id is invalid. There are no disks with the specified disk id";
    case ERROR_VOLMGR_DISK_INVALID                                                : return "The specified disk is an invalid disk. Operation cannot complete on an invalid disk";
    case ERROR_VOLMGR_DISK_LAST_VOTER                                             : return "The specified disk(s) cannot be removed since it is the last remaining voter";
    case ERROR_VOLMGR_DISK_LAYOUT_INVALID                                         : return "The specified disk has an invalid disk layout";
    case ERROR_VOLMGR_DISK_LAYOUT_NON_BASIC_BETWEEN_BASIC_PARTITIONS              : return "The disk layout contains non-basic partitions which appear after basic paritions. This is an invalid disk layout";
    case ERROR_VOLMGR_DISK_LAYOUT_NOT_CYLINDER_ALIGNED                            : return "The disk layout contains partitions which are not cylinder aligned";
    case ERROR_VOLMGR_DISK_LAYOUT_PARTITIONS_TOO_SMALL                            : return "The disk layout contains partitions which are samller than the minimum size";
    case ERROR_VOLMGR_DISK_LAYOUT_PRIMARY_BETWEEN_LOGICAL_PARTITIONS              : return "The disk layout contains primary partitions in between logical drives. This is an invalid disk layout";
    case ERROR_VOLMGR_DISK_LAYOUT_TOO_MANY_PARTITIONS                             : return "The disk layout contains more than the maximum number of supported partitions";
    case ERROR_VOLMGR_DISK_MISSING                                                : return "The specified disk is missing. The operation cannot complete on a missing disk";
    case ERROR_VOLMGR_DISK_NOT_EMPTY                                              : return "The specified disk is not empty";
    case ERROR_VOLMGR_DISK_NOT_ENOUGH_SPACE                                       : return "There is not enough usable space for this operation";
    case ERROR_VOLMGR_DISK_REVECTORING_FAILED                                     : return "The force revectoring of bad sectors failed";
    case ERROR_VOLMGR_DISK_SECTOR_SIZE_INVALID                                    : return "The specified disk has an invalid sector size";
    case ERROR_VOLMGR_DISK_SET_NOT_CONTAINED                                      : return "The specified disk set contains volumes which exist on disks outside of the set";
    case ERROR_VOLMGR_DISK_USED_BY_MULTIPLE_MEMBERS                               : return "A disk in the volume layout provides extents to more than one member of a plex";
    case ERROR_VOLMGR_DISK_USED_BY_MULTIPLE_PLEXES                                : return "A disk in the volume layout provides extents to more than one plex";
    case ERROR_VOLMGR_DYNAMIC_DISK_NOT_SUPPORTED                                  : return "Dynamic disks are not supported on this system";
    case ERROR_VOLMGR_EXTENT_ALREADY_USED                                         : return "The specified extent is already used by other volumes";
    case ERROR_VOLMGR_EXTENT_NOT_CONTIGUOUS                                       : return "The specified volume is retained and can only be extended into a contiguous extent. The specified extent to grow the volume is not contiguous with the specified volume";
    case ERROR_VOLMGR_EXTENT_NOT_IN_PUBLIC_REGION                                 : return "The specified volume extent is not within the public region of the disk";
    case ERROR_VOLMGR_EXTENT_NOT_SECTOR_ALIGNED                                   : return "The specifed volume extent is not sector aligned";
    case ERROR_VOLMGR_EXTENT_OVERLAPS_EBR_PARTITION                               : return "The specified parition overlaps an EBR (the first track of an extended partition on a MBR disks)";
    case ERROR_VOLMGR_EXTENT_VOLUME_LENGTHS_DO_NOT_MATCH                          : return "The specified extent lengths cannot be used to construct a volume with specified length";
    case ERROR_VOLMGR_FAULT_TOLERANT_NOT_SUPPORTED                                : return "The system does not support fault tolerant volumes";
    case ERROR_VOLMGR_INTERLEAVE_LENGTH_INVALID                                   : return "The specified interleave length is invalid";
    case ERROR_VOLMGR_MAXIMUM_REGISTERED_USERS                                    : return "There is already a maximum number of registered users";
    case ERROR_VOLMGR_MEMBER_IN_SYNC                                              : return "The specified member is already in-sync with the other active members. It does not need to be regenerated";
    case ERROR_VOLMGR_MEMBER_INDEX_DUPLICATE                                      : return "The same member index was specified more than once";
    case ERROR_VOLMGR_MEMBER_INDEX_INVALID                                        : return "The specified member index is greater or equal than the number of members in the volume plex";
    case ERROR_VOLMGR_MEMBER_MISSING                                              : return "The specified member is missing. It cannot be regenerated";
    case ERROR_VOLMGR_MEMBER_NOT_DETACHED                                         : return "The specified member is not detached. Cannot replace a member which is not detached";
    case ERROR_VOLMGR_MEMBER_REGENERATING                                         : return "The specified member is already regenerating";
    case ERROR_VOLMGR_ALL_DISKS_FAILED                                            : return "All disks belonging to the pack failed";
    case ERROR_VOLMGR_NO_REGISTERED_USERS                                         : return "There are currently no registered users for notifications. The task number is irrelevant unless there are registered users";
    case ERROR_VOLMGR_NO_SUCH_USER                                                : return "The specified notification user does not exist. Failed to unregister user for notifications";
    case ERROR_VOLMGR_NOTIFICATION_RESET                                          : return "The notifications have been reset. Notifications for the current user are invalid. Unregister and re-register for notifications";
    case ERROR_VOLMGR_NUMBER_OF_MEMBERS_INVALID                                   : return "The specified number of members is invalid";
    case ERROR_VOLMGR_NUMBER_OF_PLEXES_INVALID                                    : return "The specified number of plexes is invalid";
    case ERROR_VOLMGR_PACK_DUPLICATE                                              : return "The specified source and target packs are identical";
    case ERROR_VOLMGR_PACK_ID_INVALID                                             : return "The specified pack id is invalid. There are no packs with the specified pack id";
    case ERROR_VOLMGR_PACK_INVALID                                                : return "The specified pack is the invalid pack. The operation cannot complete with the invalid pack";
    case ERROR_VOLMGR_PACK_NAME_INVALID                                           : return "The specified pack name is invalid";
    case ERROR_VOLMGR_PACK_OFFLINE                                                : return "The specified pack is offline";
    case ERROR_VOLMGR_PACK_HAS_QUORUM                                             : return "The specified pack already has a quorum of healthy disks";
    case ERROR_VOLMGR_PACK_WITHOUT_QUORUM                                         : return "The pack does not have a quorum of healthy disks";
    case ERROR_VOLMGR_PARTITION_STYLE_INVALID                                     : return "The specified disk has an unsupported partition style. Only MBR and GPT partition styles are supported";
    case ERROR_VOLMGR_PARTITION_UPDATE_FAILED                                     : return "Failed to update the disk's partition layout";
    case ERROR_VOLMGR_PLEX_IN_SYNC                                                : return "The specified plex is already in-sync with the other active plexes. It does not need to be regenerated";
    case ERROR_VOLMGR_PLEX_INDEX_DUPLICATE                                        : return "The same plex index was specified more than once";
    case ERROR_VOLMGR_PLEX_INDEX_INVALID                                          : return "The specified plex index is greater or equal than the number of plexes in the volume";
    case ERROR_VOLMGR_PLEX_LAST_ACTIVE                                            : return "The specified plex is the last active plex in the volume. The plex cannot be removed or else the volume will go offline";
    case ERROR_VOLMGR_PLEX_MISSING                                                : return "The specified plex is missing";
    case ERROR_VOLMGR_PLEX_REGENERATING                                           : return "The specified plex is currently regenerating";
    case ERROR_VOLMGR_PLEX_TYPE_INVALID                                           : return "The specified plex type is invalid";
    case ERROR_VOLMGR_PLEX_NOT_RAID5                                              : return "The operation is only supported on RAID-5 plexes";
    case ERROR_VOLMGR_PLEX_NOT_SIMPLE                                             : return "The operation is only supported on simple plexes";
    case ERROR_VOLMGR_STRUCTURE_SIZE_INVALID                                      : return "The Size fields in the VM_VOLUME_LAYOUT input structure are incorrectly set";
    case ERROR_VOLMGR_TOO_MANY_NOTIFICATION_REQUESTS                              : return "There is already a pending request for notifications. Wait for the existing request to return before requesting for more notifications";
    case ERROR_VOLMGR_TRANSACTION_IN_PROGRESS                                     : return "There is currently a transaction in process";
    case ERROR_VOLMGR_UNEXPECTED_DISK_LAYOUT_CHANGE                               : return "An unexpected layout change occurred outside of the volume manager";
    case ERROR_VOLMGR_VOLUME_CONTAINS_MISSING_DISK                                : return "The specified volume contains a missing disk";
    case ERROR_VOLMGR_VOLUME_ID_INVALID                                           : return "The specified volume id is invalid. There are no volumes with the specified volume id";
    case ERROR_VOLMGR_VOLUME_LENGTH_INVALID                                       : return "The specified volume length is invalid";
    case ERROR_VOLMGR_VOLUME_LENGTH_NOT_SECTOR_SIZE_MULTIPLE                      : return "The specified size for the volume is not a multiple of the sector size";
    case ERROR_VOLMGR_VOLUME_NOT_MIRRORED                                         : return "The operation is only supported on mirrored volumes";
    case ERROR_VOLMGR_VOLUME_NOT_RETAINED                                         : return "The specified volume does not have a retain partition";
    case ERROR_VOLMGR_VOLUME_OFFLINE                                              : return "The specified volume is offline";
    case ERROR_VOLMGR_VOLUME_RETAINED                                             : return "The specified volume already has a retain partition";
    case ERROR_VOLMGR_NUMBER_OF_EXTENTS_INVALID                                   : return "The specified number of extents is invalid";
    case ERROR_VOLMGR_DIFFERENT_SECTOR_SIZE                                       : return "All disks participating to the volume must have the same sector size";
    case ERROR_VOLMGR_BAD_BOOT_DISK                                               : return "The boot disk experienced failures";
    case ERROR_VOLMGR_PACK_CONFIG_OFFLINE                                         : return "The configuration of the pack is offline";
    case ERROR_VOLMGR_PACK_CONFIG_ONLINE                                          : return "The configuration of the pack is online";
    case ERROR_VOLMGR_NOT_PRIMARY_PACK                                            : return "The specified pack is not the primary pack";
    case ERROR_VOLMGR_PACK_LOG_UPDATE_FAILED                                      : return "All disks failed to be updated with the new content of the log";
    case ERROR_VOLMGR_NUMBER_OF_DISKS_IN_PLEX_INVALID                             : return "The specified number of disks in a plex is invalid";
    case ERROR_VOLMGR_NUMBER_OF_DISKS_IN_MEMBER_INVALID                           : return "The specified number of disks in a plex member is invalid";
    case ERROR_VOLMGR_VOLUME_MIRRORED                                             : return "The operation is not supported on mirrored volumes";
    case ERROR_VOLMGR_PLEX_NOT_SIMPLE_SPANNED                                     : return "The operation is only supported on simple and spanned plexes";
    case ERROR_VOLMGR_NO_VALID_LOG_COPIES                                         : return "The pack has no valid log copies";
    case ERROR_VOLMGR_PRIMARY_PACK_PRESENT                                        : return "A primary pack is already present";
    case ERROR_VOLMGR_NUMBER_OF_DISKS_INVALID                                     : return "The specified number of disks is invalid";
    case ERROR_VOLMGR_MIRROR_NOT_SUPPORTED                                        : return "The system does not support mirrored volumes";
    case ERROR_VOLMGR_RAID5_NOT_SUPPORTED                                         : return "The system does not support RAID-5 volumes";
    case ERROR_BCD_NOT_ALL_ENTRIES_IMPORTED                                       : return "Some BCD entries were not imported correctly from the BCD store";
    case ERROR_BCD_TOO_MANY_ELEMENTS                                              : return "Entries enumerated have exceeded the allowed threshold";
    case ERROR_BCD_NOT_ALL_ENTRIES_SYNCHRONIZED                                   : return "Some BCD entries were not synchronized correctly with the firmware";
    case ERROR_VHD_DRIVE_FOOTER_MISSING                                           : return "The virtual hard disk is corrupted. The virtual hard disk drive footer is missing";
    case ERROR_VHD_DRIVE_FOOTER_CHECKSUM_MISMATCH                                 : return "The virtual hard disk is corrupted. The virtual hard disk drive footer checksum does not match the on-disk checksum";
    case ERROR_VHD_DRIVE_FOOTER_CORRUPT                                           : return "The virtual hard disk is corrupted. The virtual hard disk drive footer in the virtual hard disk is corrupted";
    case ERROR_VHD_FORMAT_UNKNOWN                                                 : return "The system does not recognize the file format of this virtual hard disk";
    case ERROR_VHD_FORMAT_UNSUPPORTED_VERSION                                     : return "The version does not support this version of the file format";
    case ERROR_VHD_SPARSE_HEADER_CHECKSUM_MISMATCH                                : return "The virtual hard disk is corrupted. The sparse header checksum does not match the on-disk checksum";
    case ERROR_VHD_SPARSE_HEADER_UNSUPPORTED_VERSION                              : return "The system does not support this version of the virtual hard disk.This version of the sparse header is not supported";
    case ERROR_VHD_SPARSE_HEADER_CORRUPT                                          : return "The virtual hard disk is corrupted. The sparse header in the virtual hard disk is corrupt";
    case ERROR_VHD_BLOCK_ALLOCATION_FAILURE                                       : return "Failed to write to the virtual hard disk failed because the system failed to allocate a new block in the virtual hard disk";
    case ERROR_VHD_BLOCK_ALLOCATION_TABLE_CORRUPT                                 : return "The virtual hard disk is corrupted. The block allocation table in the virtual hard disk is corrupt";
    case ERROR_VHD_INVALID_BLOCK_SIZE                                             : return "The system does not support this version of the virtual hard disk. The block size is invalid";
    case ERROR_VHD_BITMAP_MISMATCH                                                : return "The virtual hard disk is corrupted. The block bitmap does not match with the block data present in the virtual hard disk";
    case ERROR_VHD_PARENT_VHD_NOT_FOUND                                           : return "The chain of virtual hard disks is broken. The system cannot locate the parent virtual hard disk for the differencing disk";
    case ERROR_VHD_CHILD_PARENT_ID_MISMATCH                                       : return "The chain of virtual hard disks is corrupted. There is a mismatch in the identifiers of the parent virtual hard disk and differencing disk";
    case ERROR_VHD_CHILD_PARENT_TIMESTAMP_MISMATCH                                : return "The chain of virtual hard disks is corrupted. The time stamp of the parent virtual hard disk does not match the time stamp of the differencing disk";
    case ERROR_VHD_METADATA_READ_FAILURE                                          : return "Failed to read the metadata of the virtual hard disk";
    case ERROR_VHD_METADATA_WRITE_FAILURE                                         : return "Failed to write to the metadata of the virtual hard disk";
    case ERROR_VHD_INVALID_SIZE                                                   : return "The size of the virtual hard disk is not valid";
    case ERROR_VHD_INVALID_FILE_SIZE                                              : return "The file size of this virtual hard disk is not valid";
    case ERROR_VIRTDISK_PROVIDER_NOT_FOUND                                        : return "A virtual disk support provider for the specified file was not found";
    case ERROR_VIRTDISK_NOT_VIRTUAL_DISK                                          : return "The specified disk is not a virtual disk";
    case ERROR_VHD_PARENT_VHD_ACCESS_DENIED                                       : return "The chain of virtual hard disks is inaccessible. The process has not been granted access rights to the parent virtual hard disk for the differencing disk";
    case ERROR_VHD_CHILD_PARENT_SIZE_MISMATCH                                     : return "The chain of virtual hard disks is corrupted. There is a mismatch in the virtual sizes of the parent virtual hard disk and differencing disk";
    case ERROR_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED                              : return "The chain of virtual hard disks is corrupted. A differencing disk is indicated in its own parent chain";
    case ERROR_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT                             : return "The chain of virtual hard disks is inaccessible. There was an error opening a virtual hard disk further up the chain";
    case ERROR_VIRTUAL_DISK_LIMITATION                                            : return "The requested operation could not be completed due to a virtual disk system limitation.  Virtual hard disk files must be uncompressed and unencrypted and must not be sparse";
    case ERROR_VHD_INVALID_TYPE                                                   : return "The requested operation cannot be performed on a virtual disk of this type";
    case ERROR_VHD_INVALID_STATE                                                  : return "The requested operation cannot be performed on the virtual disk in its current state";
    case ERROR_VIRTDISK_UNSUPPORTED_DISK_SECTOR_SIZE                              : return "The sector size of the physical disk on which the virtual disk resides is not supported";
    case ERROR_VIRTDISK_DISK_ALREADY_OWNED                                        : return "The disk is already owned by a different owner";
    case ERROR_VIRTDISK_DISK_ONLINE_AND_WRITABLE                                  : return "The disk must be offline or read-only";
    case ERROR_CTLOG_TRACKING_NOT_INITIALIZED                                     : return "Change Tracking is not initialized for this virtual disk";
    case ERROR_CTLOG_LOGFILE_SIZE_EXCEEDED_MAXSIZE                                : return "Size of change tracking file exceeded the maximum size limit";
    case ERROR_CTLOG_VHD_CHANGED_OFFLINE                                          : return "VHD file is changed due to compaction, expansion, or offline updates";
    case ERROR_CTLOG_INVALID_TRACKING_STATE                                       : return "Change Tracking for the virtual disk is not in a valid state to perform this request.  Change tracking could be discontinued or already in the requested state";
    case ERROR_CTLOG_INCONSISTENT_TRACKING_FILE                                   : return "Change Tracking file for the virtual disk is not in a valid state";
    case ERROR_VHD_RESIZE_WOULD_TRUNCATE_DATA                                     : return "The requested resize operation could not be completed because it might truncate user data residing on the virtual disk";
    case ERROR_VHD_COULD_NOT_COMPUTE_MINIMUM_VIRTUAL_SIZE                         : return "The requested operation could not be completed because the virtual disk's minimum safe size could not be determined";
    case ERROR_VHD_ALREADY_AT_OR_BELOW_MINIMUM_VIRTUAL_SIZE                       : return "The requested operation could not be completed because the virtual disk's size cannot be safely reduced further";
    case ERROR_VHD_METADATA_FULL                                                  : return "There is not enough space in the virtual disk file for the provided metadata item";
    case ERROR_VHD_INVALID_CHANGE_TRACKING_ID                                     : return "The specified change tracking identifier is not valid";
    case ERROR_VHD_CHANGE_TRACKING_DISABLED                                       : return "Change tracking is disabled for the specified virtual hard disk, so no change tracking information is available";
    case ERROR_VHD_MISSING_CHANGE_TRACKING_INFORMATION                            : return "There is no change tracking data available associated with the specified change tracking identifier";
    case ERROR_QUERY_STORAGE_ERROR                                                : return "The virtualization storage subsystem has generated an error";
    case HNS_NETWORK_NOT_FOUND                                                    : return "The network was not found";
    case HNS_ENDPOINT_NOT_FOUND                                                   : return "The endpoint was not found";
    case HNS_LAYER_NOT_FOUND                                                      : return "The network's underlying layer was not found";
    case HNS_SWITCH_NOT_FOUND                                                     : return "The virtual switch was not found";
    case HNS_SUBNET_NOT_FOUND                                                     : return "The network does not have a subnet for this endpoint";
    case HNS_ADAPTER_NOT_FOUND                                                    : return "An adapter was not found";
    case HNS_PORT_NOT_FOUND                                                       : return "The switch-port was not found";
    case HNS_POLICY_NOT_FOUND                                                     : return "An expected policy was not found";
    case HNS_VFP_PORTSETTING_NOT_FOUND                                            : return "A required VFP port setting was not found";
    case HNS_INVALID_NETWORK                                                      : return "The provided network configuration is invalid or missing parameters";
    case HNS_INVALID_NETWORK_TYPE                                                 : return "Invalid network type";
    case HNS_INVALID_ENDPOINT                                                     : return "The provided endpoint configuration is invalid or missing parameters";
    case HNS_INVALID_POLICY                                                       : return "The provided policy configuration is invalid or missing parameters";
    case HNS_INVALID_POLICY_TYPE                                                  : return "Invalid policy type";
    case HNS_INVALID_REMOTE_ENDPOINT_OPERATION                                    : return "This requested operation is invalid for a remote endpoint";
    case HNS_NETWORK_ALREADY_EXISTS                                               : return "A network with this name already exists";
    case HNS_LAYER_ALREADY_EXISTS                                                 : return "A network with this name already exists";
    case HNS_POLICY_ALREADY_EXISTS                                                : return "Policy information already exists on this object";
    case HNS_PORT_ALREADY_EXISTS                                                  : return "The specified port already exists";
    case HNS_ENDPOINT_ALREADY_ATTACHED                                            : return "This endpoint is already attached to the switch";
    case HNS_REQUEST_UNSUPPORTED                                                  : return "The specified request is unsupported";
    case HNS_MAPPING_NOT_SUPPORTED                                                : return "Port mapping is not supported on the given network";
    case HNS_DEGRADED_OPERATION                                                   : return "There was an operation attempted on a degraded object";
    case HNS_SHARED_SWITCH_MODIFICATION                                           : return "Cannot modify a switch shared by multiple networks";
    case HNS_GUID_CONVERSION_FAILURE                                              : return "Failed to interpret a parameter as a GUID";
    case HNS_REGKEY_FAILURE                                                       : return "Failed to process registry key";
    case HNS_INVALID_JSON                                                         : return "Invalid Json document string";
    case HNS_INVALID_JSON_REFERENCE                                               : return "The reference is invalid in the json document";
    case HNS_ENDPOINT_SHARING_DISABLED                                            : return "Endpoint sharing is disabled";
    case HNS_INVALID_IP                                                           : return "IP address is either invalid or not part of any configured subnet(s)";
    case SDIAG_E_CANCELLED                                                        : return "The operation was cancelled";
    case SDIAG_E_SCRIPT                                                           : return "An error occurred when running a PowerShell script";
    case SDIAG_E_POWERSHELL                                                       : return "An error occurred when interacting with PowerShell runtime";
    case SDIAG_E_MANAGEDHOST                                                      : return "An error occurred in the Scripted Diagnostic Managed Host";
    case SDIAG_E_NOVERIFIER                                                       : return "The troubleshooting pack does not contain a required verifier to complete the verification";
    case SDIAG_S_CANNOTRUN                                                        : return "The troubleshooting pack cannot be executed on this system";
    case SDIAG_E_DISABLED                                                         : return "Scripted diagnostics is disabled by group policy";
    case SDIAG_E_TRUST                                                            : return "Trust validation of the troubleshooting pack failed";
    case SDIAG_E_CANNOTRUN                                                        : return "The troubleshooting pack cannot be executed on this system";
    case SDIAG_E_VERSION                                                          : return "This version of the troubleshooting pack is not supported";
    case SDIAG_E_RESOURCE                                                         : return "A required resource cannot be loaded";
    case SDIAG_E_ROOTCAUSE                                                        : return "The troubleshooting pack reported information for a root cause without adding the root cause";
    case WPN_E_CHANNEL_CLOSED                                                     : return "The notification channel has already been closed";
    case WPN_E_CHANNEL_REQUEST_NOT_COMPLETE                                       : return "The notification channel request did not complete successfully";
    case WPN_E_INVALID_APP                                                        : return "The application identifier provided is invalid";
    case WPN_E_OUTSTANDING_CHANNEL_REQUEST                                        : return "A notification channel request for the provided application identifier is in progress";
    case WPN_E_DUPLICATE_CHANNEL                                                  : return "The channel identifier is already tied to another application endpoint";
    case WPN_E_PLATFORM_UNAVAILABLE                                               : return "The notification platform is unavailable";
    case WPN_E_NOTIFICATION_POSTED                                                : return "The notification has already been posted";
    case WPN_E_NOTIFICATION_HIDDEN                                                : return "The notification has already been hidden";
    case WPN_E_NOTIFICATION_NOT_POSTED                                            : return "The notification cannot be hidden until it has been shown";
    case WPN_E_CLOUD_DISABLED                                                     : return "Cloud notifications have been turned off";
    case WPN_E_CLOUD_INCAPABLE                                                    : return "The application does not have the cloud notification capability";
    case WPN_E_CLOUD_AUTH_UNAVAILABLE                                             : return "The notification platform is unable to retrieve the authentication credentials required to connect to the cloud notification service";
    case WPN_E_CLOUD_SERVICE_UNAVAILABLE                                          : return "The notification platform is unable to connect to the cloud notification service";
    case WPN_E_FAILED_LOCK_SCREEN_UPDATE_INTIALIZATION                            : return "The notification platform is unable to initialize a callback for lock screen updates";
    case WPN_E_NOTIFICATION_DISABLED                                              : return "Settings prevent the notification from being delivered";
    case WPN_E_NOTIFICATION_INCAPABLE                                             : return "Application capabilities prevent the notification from being delivered";
    case WPN_E_INTERNET_INCAPABLE                                                 : return "The application does not have the internet access capability";
    case WPN_E_NOTIFICATION_TYPE_DISABLED                                         : return "Settings prevent the notification type from being delivered";
    case WPN_E_NOTIFICATION_SIZE                                                  : return "The size of the notification content is too large";
    case WPN_E_TAG_SIZE                                                           : return "The size of the notification tag is too large";
    case WPN_E_ACCESS_DENIED                                                      : return "The notification platform doesn't have appropriate privilege on resources";
    case WPN_E_DUPLICATE_REGISTRATION                                             : return "The notification platform found application is already registered";
    case WPN_E_PUSH_NOTIFICATION_INCAPABLE                                        : return "The application background task does not have the push notification capability";
    case WPN_E_DEV_ID_SIZE                                                        : return "The size of the developer id for scheduled notification is too large";
    case WPN_E_TAG_ALPHANUMERIC                                                   : return "The notification tag is not alphanumeric";
    case WPN_E_INVALID_HTTP_STATUS_CODE                                           : return "The notification platform has received invalid HTTP status code other than 2xx for polling";
    case WPN_E_OUT_OF_SESSION                                                     : return "The notification platform has run out of presentation layer sessions";
    case WPN_E_POWER_SAVE                                                         : return "The notification platform rejects image download request due to system in power save mode";
    case WPN_E_IMAGE_NOT_FOUND_IN_CACHE                                           : return "The notification platform doesn't have the requested image in its cache";
    case WPN_E_ALL_URL_NOT_COMPLETED                                              : return "The notification platform cannot complete all of requested image";
    case WPN_E_INVALID_CLOUD_IMAGE                                                : return "A cloud image downloaded from the notification platform is invalid";
    case WPN_E_NOTIFICATION_ID_MATCHED                                            : return "Notification Id provided as filter is matched with what the notification platform maintains";
    case WPN_E_CALLBACK_ALREADY_REGISTERED                                        : return "Notification callback interface is already registered";
    case WPN_E_TOAST_NOTIFICATION_DROPPED                                         : return "Toast Notification was dropped without being displayed to the user";
    case WPN_E_STORAGE_LOCKED                                                     : return "The notification platform does not have the proper privileges to complete the request";
    case WPN_E_GROUP_SIZE                                                         : return "The size of the notification group is too large";
    case WPN_E_GROUP_ALPHANUMERIC                                                 : return "The notification group is not alphanumeric";
    case WPN_E_CLOUD_DISABLED_FOR_APP                                             : return "Cloud notifications have been disabled for the application due to a policy setting";
    case E_MBN_CONTEXT_NOT_ACTIVATED                                              : return "Context is not activated";
    case E_MBN_BAD_SIM                                                            : return "Bad SIM is inserted";
    case E_MBN_DATA_CLASS_NOT_AVAILABLE                                           : return "Requested data class is not avaialable";
    case E_MBN_INVALID_ACCESS_STRING                                              : return "Access point name (APN) or Access string is incorrect";
    case E_MBN_MAX_ACTIVATED_CONTEXTS                                             : return "Max activated contexts have reached";
    case E_MBN_PACKET_SVC_DETACHED                                                : return "Device is in packet detach state";
    case E_MBN_PROVIDER_NOT_VISIBLE                                               : return "Provider is not visible";
    case E_MBN_RADIO_POWER_OFF                                                    : return "Radio is powered off";
    case E_MBN_SERVICE_NOT_ACTIVATED                                              : return "MBN subscription is not activated";
    case E_MBN_SIM_NOT_INSERTED                                                   : return "SIM is not inserted";
    case E_MBN_VOICE_CALL_IN_PROGRESS                                             : return "Voice call in progress";
    case E_MBN_INVALID_CACHE                                                      : return "Visible provider cache is invalid";
    case E_MBN_NOT_REGISTERED                                                     : return "Device is not registered";
    case E_MBN_PROVIDERS_NOT_FOUND                                                : return "Providers not found";
    case E_MBN_PIN_NOT_SUPPORTED                                                  : return "Pin is not supported";
    case E_MBN_PIN_REQUIRED                                                       : return "Pin is required";
    case E_MBN_PIN_DISABLED                                                       : return "PIN is disabled";
    case E_MBN_FAILURE                                                            : return "Generic Failure";
    case E_MBN_INVALID_PROFILE                                                    : return "Profile is invalid";
    case E_MBN_DEFAULT_PROFILE_EXIST                                              : return "Default profile exist";
    case E_MBN_SMS_ENCODING_NOT_SUPPORTED                                         : return "SMS encoding is not supported";
    case E_MBN_SMS_FILTER_NOT_SUPPORTED                                           : return "SMS filter is not supported";
    case E_MBN_SMS_INVALID_MEMORY_INDEX                                           : return "Invalid SMS memory index is used";
    case E_MBN_SMS_LANG_NOT_SUPPORTED                                             : return "SMS language is not supported";
    case E_MBN_SMS_MEMORY_FAILURE                                                 : return "SMS memory failure occurred";
    case E_MBN_SMS_NETWORK_TIMEOUT                                                : return "SMS network timeout happened";
    case E_MBN_SMS_UNKNOWN_SMSC_ADDRESS                                           : return "Unknown SMSC address is used";
    case E_MBN_SMS_FORMAT_NOT_SUPPORTED                                           : return "SMS format is not supported";
    case E_MBN_SMS_OPERATION_NOT_ALLOWED                                          : return "SMS operation is not allowed";
    case E_MBN_SMS_MEMORY_FULL                                                    : return "Device SMS memory is full";
    case PEER_E_IPV6_NOT_INSTALLED                                                : return "The IPv6 protocol is not installed";
    case PEER_E_NOT_INITIALIZED                                                   : return "The compoment has not been initialized";
    case PEER_E_CANNOT_START_SERVICE                                              : return "The required service canot be started";
    case PEER_E_NOT_LICENSED                                                      : return "The P2P protocol is not licensed to run on this OS";
    case PEER_E_INVALID_GRAPH                                                     : return "The graph handle is invalid";
    case PEER_E_DBNAME_CHANGED                                                    : return "The graph database name has changed";
    case PEER_E_DUPLICATE_GRAPH                                                   : return "A graph with the same ID already exists";
    case PEER_E_GRAPH_NOT_READY                                                   : return "The graph is not ready";
    case PEER_E_GRAPH_SHUTTING_DOWN                                               : return "The graph is shutting down";
    case PEER_E_GRAPH_IN_USE                                                      : return "The graph is still in use";
    case PEER_E_INVALID_DATABASE                                                  : return "The graph database is corrupt";
    case PEER_E_TOO_MANY_ATTRIBUTES                                               : return "Too many attributes have been used";
    case PEER_E_CONNECTION_NOT_FOUND                                              : return "The connection can not be found";
    case PEER_E_CONNECT_SELF                                                      : return "The peer attempted to connect to itself";
    case PEER_E_ALREADY_LISTENING                                                 : return "The peer is already listening for connections";
    case PEER_E_NODE_NOT_FOUND                                                    : return "The node was not found";
    case PEER_E_CONNECTION_FAILED                                                 : return "The Connection attempt failed";
    case PEER_E_CONNECTION_NOT_AUTHENTICATED                                      : return "The peer connection could not be authenticated";
    case PEER_E_CONNECTION_REFUSED                                                : return "The connection was refused";
    case PEER_E_CLASSIFIER_TOO_LONG                                               : return "The peer name classifier is too long";
    case PEER_E_TOO_MANY_IDENTITIES                                               : return "The maximum number of identities have been created";
    case PEER_E_NO_KEY_ACCESS                                                     : return "Unable to access a key";
    case PEER_E_GROUPS_EXIST                                                      : return "The group already exists";
    case PEER_E_RECORD_NOT_FOUND                                                  : return "The requested record could not be found";
    case PEER_E_DATABASE_ACCESSDENIED                                             : return "Access to the database was denied";
    case PEER_E_DBINITIALIZATION_FAILED                                           : return "The Database could not be initialized";
    case PEER_E_MAX_RECORD_SIZE_EXCEEDED                                          : return "The record is too big";
    case PEER_E_DATABASE_ALREADY_PRESENT                                          : return "The database already exists";
    case PEER_E_DATABASE_NOT_PRESENT                                              : return "The database could not be found";
    case PEER_E_IDENTITY_NOT_FOUND                                                : return "The identity could not be found";
    case PEER_E_EVENT_HANDLE_NOT_FOUND                                            : return "The event handle could not be found";
    case PEER_E_INVALID_SEARCH                                                    : return "Invalid search";
    case PEER_E_INVALID_ATTRIBUTES                                                : return "The search atributes are invalid";
    case PEER_E_INVITATION_NOT_TRUSTED                                            : return "The invitiation is not trusted";
    case PEER_E_CHAIN_TOO_LONG                                                    : return "The certchain is too long";
    case PEER_E_INVALID_TIME_PERIOD                                               : return "The time period is invalid";
    case PEER_E_CIRCULAR_CHAIN_DETECTED                                           : return "A circular cert chain was detected";
    case PEER_E_CERT_STORE_CORRUPTED                                              : return "The certstore is corrupted";
    case PEER_E_NO_CLOUD                                                          : return "The specified PNRP cloud deos not exist";
    case PEER_E_CLOUD_NAME_AMBIGUOUS                                              : return "The cloud name is ambiguous";
    case PEER_E_INVALID_RECORD                                                    : return "The record is invlaid";
    case PEER_E_NOT_AUTHORIZED                                                    : return "Not authorized";
    case PEER_E_PASSWORD_DOES_NOT_MEET_POLICY                                     : return "The password does not meet policy requirements";
    case PEER_E_DEFERRED_VALIDATION                                               : return "The record validation has been defered";
    case PEER_E_INVALID_GROUP_PROPERTIES                                          : return "The group properies are invalid";
    case PEER_E_INVALID_PEER_NAME                                                 : return "The peername is invalid";
    case PEER_E_INVALID_CLASSIFIER                                                : return "The classifier is invalid";
    case PEER_E_INVALID_FRIENDLY_NAME                                             : return "The friendly name is invalid";
    case PEER_E_INVALID_ROLE_PROPERTY                                             : return "Invalid role property";
    case PEER_E_INVALID_CLASSIFIER_PROPERTY                                       : return "Invalid classifer property";
    case PEER_E_INVALID_RECORD_EXPIRATION                                         : return "Invlaid record expiration";
    case PEER_E_INVALID_CREDENTIAL_INFO                                           : return "Invlaid credential info";
    case PEER_E_INVALID_CREDENTIAL                                                : return "Invalid credential";
    case PEER_E_INVALID_RECORD_SIZE                                               : return "Invalid record size";
    case PEER_E_UNSUPPORTED_VERSION                                               : return "Unsupported version";
    case PEER_E_GROUP_NOT_READY                                                   : return "The group is not ready";
    case PEER_E_GROUP_IN_USE                                                      : return "The group is still in use";
    case PEER_E_INVALID_GROUP                                                     : return "The group is invalid";
    case PEER_E_NO_MEMBERS_FOUND                                                  : return "No members were found";
    case PEER_E_NO_MEMBER_CONNECTIONS                                             : return "There are no member connections";
    case PEER_E_UNABLE_TO_LISTEN                                                  : return "Unable to listen";
    case PEER_E_IDENTITY_DELETED                                                  : return "The identity does not exist";
    case PEER_E_SERVICE_NOT_AVAILABLE                                             : return "The service is not availible";
    case PEER_E_CONTACT_NOT_FOUND                                                 : return "THe contact could not be found";
    case PEER_S_GRAPH_DATA_CREATED                                                : return "The graph data was created";
    case PEER_S_NO_EVENT_DATA                                                     : return "There is not more event data";
    case PEER_S_ALREADY_CONNECTED                                                 : return "The graph is already connect";
    case PEER_S_SUBSCRIPTION_EXISTS                                               : return "The subscription already exists";
    case PEER_S_NO_CONNECTIVITY                                                   : return "No connectivity";
    case PEER_S_ALREADY_A_MEMBER                                                  : return "Already a member";
    case PEER_E_CANNOT_CONVERT_PEER_NAME                                          : return "The peername could not be converted to a DNS pnrp name";
    case PEER_E_INVALID_PEER_HOST_NAME                                            : return "Invalid peer host name";
    case PEER_E_NO_MORE                                                           : return "No more data could be found";
    case PEER_E_PNRP_DUPLICATE_PEER_NAME                                          : return "The existing peer name is already registered";
    case PEER_E_INVITE_CANCELLED                                                  : return "The app invite request was cancelled by the user";
    case PEER_E_INVITE_RESPONSE_NOT_AVAILABLE                                     : return "No response of the invite was received";
    case PEER_E_NOT_SIGNED_IN                                                     : return "User is not signed into serverless presence";
    case PEER_E_PRIVACY_DECLINED                                                  : return "The user declined the privacy policy prompt";
    case PEER_E_TIMEOUT                                                           : return "A timeout occurred";
    case PEER_E_INVALID_ADDRESS                                                   : return "The address is invalid";
    case PEER_E_FW_EXCEPTION_DISABLED                                             : return "A required firewall exception is disabled";
    case PEER_E_FW_BLOCKED_BY_POLICY                                              : return "The service is blocked by a firewall policy";
    case PEER_E_FW_BLOCKED_BY_SHIELDS_UP                                          : return "Firewall exceptions are disabled";
    case PEER_E_FW_DECLINED                                                       : return "The user declined to enable the firewall exceptions";
    case UI_E_CREATE_FAILED                                                       : return "The object could not be created";
    case UI_E_SHUTDOWN_CALLED                                                     : return "Shutdown was already called on this object or the object that owns it";
    case UI_E_ILLEGAL_REENTRANCY                                                  : return "This method cannot be called during this type of callback";
    case UI_E_OBJECT_SEALED                                                       : return "This object has been sealed, so this change is no longer allowed";
    case UI_E_VALUE_NOT_SET                                                       : return "The requested value was never set";
    case UI_E_VALUE_NOT_DETERMINED                                                : return "The requested value cannot be determined";
    case UI_E_INVALID_OUTPUT                                                      : return "A callback returned an invalid output parameter";
    case UI_E_BOOLEAN_EXPECTED                                                    : return "A callback returned a success code other than S_OK or S_FALSE";
    case UI_E_DIFFERENT_OWNER                                                     : return "A parameter that should be owned by this object is owned by a different object";
    case UI_E_AMBIGUOUS_MATCH                                                     : return "More than one item matched the search criteria";
    case UI_E_FP_OVERFLOW                                                         : return "A floating-point overflow occurred";
    case UI_E_WRONG_THREAD                                                        : return "This method can only be called from the thread that created the object";
    case UI_E_STORYBOARD_ACTIVE                                                   : return "The storyboard is currently in the schedule";
    case UI_E_STORYBOARD_NOT_PLAYING                                              : return "The storyboard is not playing";
    case UI_E_START_KEYFRAME_AFTER_END                                            : return "The start keyframe might occur after the end keyframe";
    case UI_E_END_KEYFRAME_NOT_DETERMINED                                         : return "It might not be possible to determine the end keyframe time when the start keyframe is reached";
    case UI_E_LOOPS_OVERLAP                                                       : return "Two repeated portions of a storyboard might overlap";
    case UI_E_TRANSITION_ALREADY_USED                                             : return "The transition has already been added to a storyboard";
    case UI_E_TRANSITION_NOT_IN_STORYBOARD                                        : return "The transition has not been added to a storyboard";
    case UI_E_TRANSITION_ECLIPSED                                                 : return "The transition might eclipse the beginning of another transition in the storyboard";
    case UI_E_TIME_BEFORE_LAST_UPDATE                                             : return "The given time is earlier than the time passed to the last update";
    case UI_E_TIMER_CLIENT_ALREADY_CONNECTED                                      : return "This client is already connected to a timer";
    case UI_E_INVALID_DIMENSION                                                   : return "The passed dimension is invalid or does not match the object's dimension";
    case UI_E_PRIMITIVE_OUT_OF_BOUNDS                                             : return "The added primitive begins at or beyond the duration of the interpolator";
    case UI_E_WINDOW_CLOSED                                                       : return "The operation cannot be completed because the window is being closed";
    case E_BLUETOOTH_ATT_INVALID_HANDLE                                           : return "The attribute handle given was not valid on this server";
    case E_BLUETOOTH_ATT_READ_NOT_PERMITTED                                       : return "The attribute cannot be read";
    case E_BLUETOOTH_ATT_WRITE_NOT_PERMITTED                                      : return "The attribute cannot be written";
    case E_BLUETOOTH_ATT_INVALID_PDU                                              : return "The attribute PDU was invalid";
    case E_BLUETOOTH_ATT_INSUFFICIENT_AUTHENTICATION                              : return "The attribute requires authentication before it can be read or written";
    case E_BLUETOOTH_ATT_REQUEST_NOT_SUPPORTED                                    : return "Attribute server does not support the request received from the client";
    case E_BLUETOOTH_ATT_INVALID_OFFSET                                           : return "Offset specified was past the end of the attribute";
    case E_BLUETOOTH_ATT_INSUFFICIENT_AUTHORIZATION                               : return "The attribute requires authorization before it can be read or written";
    case E_BLUETOOTH_ATT_PREPARE_QUEUE_FULL                                       : return "Too many prepare writes have been queued";
    case E_BLUETOOTH_ATT_ATTRIBUTE_NOT_FOUND                                      : return "No attribute found within the given attribute handle range";
    case E_BLUETOOTH_ATT_ATTRIBUTE_NOT_LONG                                       : return "The attribute cannot be read or written using the Read Blob Request";
    case E_BLUETOOTH_ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE                         : return "The Encryption Key Size used for encrypting this link is insufficient";
    case E_BLUETOOTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH                           : return "The attribute value length is invalid for the operation";
    case E_BLUETOOTH_ATT_UNLIKELY                                                 : return "The attribute request that was requested has encountered an error that was unlikely, and therefore could not be completed as requested";
    case E_BLUETOOTH_ATT_INSUFFICIENT_ENCRYPTION                                  : return "The attribute requires encryption before it can be read or written";
    case E_BLUETOOTH_ATT_UNSUPPORTED_GROUP_TYPE                                   : return "The attribute type is not a supported grouping attribute as defined by a higher layer specification";
    case E_BLUETOOTH_ATT_INSUFFICIENT_RESOURCES                                   : return "Insufficient Resources to complete the request";
    case E_BLUETOOTH_ATT_UNKNOWN_ERROR                                            : return "An error that lies in the reserved range has been received";
    case E_AUDIO_ENGINE_NODE_NOT_FOUND                                            : return "PortCls could not find an audio engine node exposed by a miniport driver claiming support for IMiniportAudioEngineNode";
    case E_HDAUDIO_EMPTY_CONNECTION_LIST                                          : return "HD Audio widget encountered an unexpected empty connection list";
    case E_HDAUDIO_CONNECTION_LIST_NOT_SUPPORTED                                  : return "HD Audio widget does not support the connection list parameter";
    case E_HDAUDIO_NO_LOGICAL_DEVICES_CREATED                                     : return "No HD Audio subdevices were successfully created";
    case E_HDAUDIO_NULL_LINKED_LIST_ENTRY                                         : return "An unexpected NULL pointer was encountered in a linked list";
    case STATEREPOSITORY_E_CONCURRENCY_LOCKING_FAILURE                            : return "Optimistic locking failure. Data cannot be updated if it has changed since it was read";
    case STATEREPOSITORY_E_STATEMENT_INPROGRESS                                   : return "A prepared statement has been stepped at least once but not run to completion or reset. This may result in busy waits";
    case STATEREPOSITORY_E_CONFIGURATION_INVALID                                  : return "The StateRepository configuration is not valid";
    case STATEREPOSITORY_E_UNKNOWN_SCHEMA_VERSION                                 : return "The StateRepository schema version is not known";
    case STATEREPOSITORY_ERROR_DICTIONARY_CORRUPTED                               : return "A StateRepository dictionary is not valid";
    case STATEREPOSITORY_E_BLOCKED                                                : return "The request failed because the StateRepository is actively blocking requests";
    case STATEREPOSITORY_E_BUSY_RETRY                                             : return "The database file is locked. The request will be retried";
    case STATEREPOSITORY_E_BUSY_RECOVERY_RETRY                                    : return "The database file is locked because another process is busy recovering the database. The request will be retried";
    case STATEREPOSITORY_E_LOCKED_RETRY                                           : return "A table in the database is locked. The request will be retried";
    case STATEREPOSITORY_E_LOCKED_SHAREDCACHE_RETRY                               : return "The shared cache for the database is locked by another connection. The request will be retried";
    case STATEREPOSITORY_E_TRANSACTION_REQUIRED                                   : return "A transaction is required to perform the request operation";
    case STATEREPOSITORY_E_BUSY_TIMEOUT_EXCEEDED                                  : return "The database file is locked. The request has exceeded the allowed threshold";
    case STATEREPOSITORY_E_BUSY_RECOVERY_TIMEOUT_EXCEEDED                         : return "The database file is locked because another process is busy recovering the database. The request has exceeded the allowed threshold";
    case STATEREPOSITORY_E_LOCKED_TIMEOUT_EXCEEDED                                : return "A table in the database is locked. The request has exceeded the allowed threshold";
    case STATEREPOSITORY_E_LOCKED_SHAREDCACHE_TIMEOUT_EXCEEDED                    : return "The shared cache for the database is locked by another connection. The request has exceeded the allowed threshold";
    case STATEREPOSITORY_E_SERVICE_STOP_IN_PROGRESS                               : return "The StateRepository service Stop event is in progress";
    case STATEREPOSTORY_E_NESTED_TRANSACTION_NOT_SUPPORTED                        : return "Nested transactions are not supported";
    case ERROR_SPACES_POOL_WAS_DELETED                                            : return "The storage pool was deleted by the driver. The object cache should be updated";
    case ERROR_SPACES_FAULT_DOMAIN_TYPE_INVALID                                   : return "The specified fault domain type or combination of minimum / maximum fault domain type is not valid";
    case ERROR_SPACES_INTERNAL_ERROR                                              : return "A Storage Spaces internal error occurred";
    case ERROR_SPACES_RESILIENCY_TYPE_INVALID                                     : return "The specified resiliency type is not valid";
    case ERROR_SPACES_DRIVE_SECTOR_SIZE_INVALID                                   : return "The physical disk's sector size is not supported by the storage pool";
    case ERROR_SPACES_DRIVE_REDUNDANCY_INVALID                                    : return "The requested redundancy is outside of the supported range of values";
    case ERROR_SPACES_NUMBER_OF_DATA_COPIES_INVALID                               : return "The number of data copies requested is outside of the supported range of values";
    case ERROR_SPACES_PARITY_LAYOUT_INVALID                                       : return "The value for ParityLayout is outside of the supported range of values";
    case ERROR_SPACES_INTERLEAVE_LENGTH_INVALID                                   : return "The value for interleave length is outside of the supported range of values or is not a power of 2";
    case ERROR_SPACES_NUMBER_OF_COLUMNS_INVALID                                   : return "The number of columns specified is outside of the supported range of values";
    case ERROR_SPACES_NOT_ENOUGH_DRIVES                                           : return "There were not enough physical disks to complete the requested operation";
    case ERROR_SPACES_EXTENDED_ERROR                                              : return "Extended error information is available";
    case ERROR_SPACES_PROVISIONING_TYPE_INVALID                                   : return "The specified provisioning type is not valid";
    case ERROR_SPACES_ALLOCATION_SIZE_INVALID                                     : return "The allocation size is outside of the supported range of values";
    case ERROR_SPACES_ENCLOSURE_AWARE_INVALID                                     : return "Enclosure awareness is not supported for this virtual disk";
    case ERROR_SPACES_WRITE_CACHE_SIZE_INVALID                                    : return "The write cache size is outside of the supported range of values";
    case ERROR_SPACES_NUMBER_OF_GROUPS_INVALID                                    : return "The value for number of groups is outside of the supported range of values";
    case ERROR_SPACES_DRIVE_OPERATIONAL_STATE_INVALID                             : return "The OperationalState of the physical disk is invalid for this operation";
    case ERROR_VOLSNAP_BOOTFILE_NOT_VALID                                         : return "The bootfile is too small to support persistent snapshots";
    case ERROR_VOLSNAP_ACTIVATION_TIMEOUT                                         : return "Activation of persistent snapshots on this volume took longer than was allowed";
    case ERROR_TIERING_NOT_SUPPORTED_ON_VOLUME                                    : return "The specified volume does not support storage tiers";
    case ERROR_TIERING_VOLUME_DISMOUNT_IN_PROGRESS                                : return "The Storage Tiers Management service detected that the specified volume is in the process of being dismounted";
    case ERROR_TIERING_STORAGE_TIER_NOT_FOUND                                     : return "The specified storage tier could not be found on the volume. Confirm that the storage tier name is valid";
    case ERROR_TIERING_INVALID_FILE_ID                                            : return "The file identifier specified is not valid on the volume";
    case ERROR_TIERING_WRONG_CLUSTER_NODE                                         : return "Storage tier operations must be called on the clustering node that owns the metadata volume";
    case ERROR_TIERING_ALREADY_PROCESSING                                         : return "The Storage Tiers Management service is already optimizing the storage tiers on the specified volume";
    case ERROR_TIERING_CANNOT_PIN_OBJECT                                          : return "The requested object type cannot be assigned to a storage tier";
    case ERROR_TIERING_FILE_IS_NOT_PINNED                                         : return "The requested file is not pinned to a tier";
    case ERROR_NOT_A_TIERED_VOLUME                                                : return "The volume is not a tiered volume";
    case ERROR_ATTRIBUTE_NOT_PRESENT                                              : return "The requested attribute is not present on the specified file or directory";
    case ERROR_SECCORE_INVALID_COMMAND                                            : return "The command was not recognized by the security core";
    case ERROR_NO_APPLICABLE_APP_LICENSES_FOUND                                   : return "No applicable app licenses found";
    case ERROR_CLIP_LICENSE_NOT_FOUND                                             : return "CLiP license not found";
    case ERROR_CLIP_DEVICE_LICENSE_MISSING                                        : return "CLiP device license not found";
    case ERROR_CLIP_LICENSE_INVALID_SIGNATURE                                     : return "CLiP license has an invalid signature";
    case ERROR_CLIP_KEYHOLDER_LICENSE_MISSING_OR_INVALID                          : return "CLiP keyholder license is invalid or missing";
    case ERROR_CLIP_LICENSE_EXPIRED                                               : return "CLiP license has expired";
    case ERROR_CLIP_LICENSE_SIGNED_BY_UNKNOWN_SOURCE                              : return "CLiP license is signed by an unknown source";
    case ERROR_CLIP_LICENSE_NOT_SIGNED                                            : return "CLiP license is not signed";
    case ERROR_CLIP_LICENSE_HARDWARE_ID_OUT_OF_TOLERANCE                          : return "CLiP license hardware ID is out of tolerance";
    case ERROR_CLIP_LICENSE_DEVICE_ID_MISMATCH                                    : return "CLiP license device ID does not match the device ID in the bound device license";
    case DXGI_STATUS_OCCLUDED                                                     : return "The Present operation was invisible to the user";
    case DXGI_STATUS_CLIPPED                                                      : return "The Present operation was partially invisible to the user";
    case DXGI_STATUS_NO_REDIRECTION                                               : return "The driver is requesting that the DXGI runtime not use shared resources to communicate with the Desktop Window Manager";
    case DXGI_STATUS_NO_DESKTOP_ACCESS                                            : return "The Present operation was not visible because the Windows session has switched to another desktop (for example, ctrl-alt-del)";
    case DXGI_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE                                 : return "The Present operation was not visible because the target monitor was being used for some other purpose";
    case DXGI_STATUS_MODE_CHANGED                                                 : return "The Present operation was not visible because the display mode changed. DXGI will have re-attempted the presentation";
    case DXGI_STATUS_MODE_CHANGE_IN_PROGRESS                                      : return "The Present operation was not visible because another Direct3D device was attempting to take fullscreen mode at the time";
    case DXGI_ERROR_INVALID_CALL                                                  : return "The application made a call that is invalid. Either the parameters of the call or the state of some object was incorrect";
    case DXGI_ERROR_NOT_FOUND                                                     : return "The object was not found. If calling IDXGIFactory::EnumAdaptes, there is no adapter with the specified ordinal";
    case DXGI_ERROR_MORE_DATA                                                     : return "The caller did not supply a sufficiently large buffer";
    case DXGI_ERROR_UNSUPPORTED                                                   : return "The specified device interface or feature level is not supported on this system";
    case DXGI_ERROR_DEVICE_REMOVED                                                : return "The GPU device instance has been suspended. Use GetDeviceRemovedReason to determine the appropriate action";
    case DXGI_ERROR_DEVICE_HUNG                                                   : return "The GPU will not respond to more commands, most likely because of an invalid command passed by the calling application";
    case DXGI_ERROR_DEVICE_RESET                                                  : return "The GPU will not respond to more commands, most likely because some other application submitted invalid commands";
    case DXGI_ERROR_WAS_STILL_DRAWING                                             : return "The GPU was busy at the moment when the call was made, and the call was neither executed nor scheduled";
    case DXGI_ERROR_FRAME_STATISTICS_DISJOINT                                     : return "An event (such as power cycle) interrupted the gathering of presentation statistics. Any previous statistics should be";
    case DXGI_ERROR_GRAPHICS_VIDPN_SOURCE_IN_USE                                  : return "Fullscreen mode could not be achieved because the specified output was already in use";
    case DXGI_ERROR_DRIVER_INTERNAL_ERROR                                         : return "An internal issue prevented the driver from carrying out the specified operation. The driver's state is probably suspect,nd the application should not continue";
    case DXGI_ERROR_NONEXCLUSIVE                                                  : return "A global counter resource was in use, and the specified counter cannot be used by this Direct3D device at this time";
    case DXGI_ERROR_NOT_CURRENTLY_AVAILABLE                                       : return "A resource is not available at the time of the call, but may become available later";
    case DXGI_ERROR_REMOTE_CLIENT_DISCONNECTED                                    : return "The application's remote device has been removed due to session disconnect or network disconnect";
    case DXGI_ERROR_REMOTE_OUTOFMEMORY                                            : return "The device has been removed during a remote session because the remote computer ran out of memory";
    case DXGI_ERROR_ACCESS_LOST                                                   : return "The keyed mutex was abandoned";
    case DXGI_ERROR_WAIT_TIMEOUT                                                  : return "The timeout value has elapsed and the resource is not yet available";
    case DXGI_ERROR_SESSION_DISCONNECTED                                          : return "The output duplication has been turned off because the Windows session ended or was disconnected";
    case DXGI_ERROR_RESTRICT_TO_OUTPUT_STALE                                      : return "The DXGI outuput (monitor) to which the swapchain content was restricted, has been disconnected or changed";
    case DXGI_ERROR_CANNOT_PROTECT_CONTENT                                        : return "DXGI is unable to provide content protection on the swapchain. This is typically caused by an older driver,r by the application using a swapchain that is incompatible with content protection";
    case DXGI_ERROR_ACCESS_DENIED                                                 : return "The application is trying to use a resource to which it does not have the required access privileges";
    case DXGI_ERROR_NAME_ALREADY_EXISTS                                           : return "The application is trying to create a shared handle using a name that is already associated with some other resource";
    case DXGI_ERROR_SDK_COMPONENT_MISSING                                         : return "The application requested an operation that depends on an SDK component that is missing or mismatched";
    case DXGI_ERROR_NOT_CURRENT                                                   : return "The DXGI objects that the application has created are no longer current & need to be recreated for this operation to be performed";
    case DXGI_ERROR_HW_PROTECTION_OUTOFMEMORY                                     : return "Insufficient HW protected memory exits for proper function";
    case DXGI_ERROR_DYNAMIC_CODE_POLICY_VIOLATION                                 : return "Creating this device would violate the process's dynamic code policy";
    case DXGI_ERROR_NON_COMPOSITED_UI                                             : return "The operation failed because the compositor is not in control of the output";
    case DXGI_STATUS_UNOCCLUDED                                                   : return "The swapchain has become unoccluded";
    case DXGI_STATUS_DDA_WAS_STILL_DRAWING                                        : return "The adapter did not have access to the required resources to complete the Desktop Duplication Present() call, the Present() call needs to be made again";
    case DXGI_ERROR_MODE_CHANGE_IN_PROGRESS                                       : return "An on-going mode change prevented completion of the call. The call may succeed if attempted later";
    case DXGI_STATUS_PRESENT_REQUIRED                                             : return "The present succeeded but the caller should present again on the next V-sync, even if there are no changes to the content";
    case DXGI_ERROR_CACHE_CORRUPT                                                 : return "The cache is corrupt and either could not be opened or could not be reset";
    case DXGI_ERROR_CACHE_FULL                                                    : return "This entry would cause the cache to exceed its quota. On a load operation, this may indicate exceeding the maximum in-memory size";
    case DXGI_ERROR_CACHE_HASH_COLLISION                                          : return "A cache entry was found, but the key provided does not match the key stored in the entry";
    case DXGI_ERROR_ALREADY_EXISTS                                                : return "The desired element already exists";
    case DXGI_DDI_ERR_WASSTILLDRAWING                                             : return "The GPU was busy when the operation was requested";
    case DXGI_DDI_ERR_UNSUPPORTED                                                 : return "The driver has rejected the creation of this resource";
    case DXGI_DDI_ERR_NONEXCLUSIVE                                                : return "The GPU counter was in use by another process or d3d device when application requested access to it";
    case D3D10_ERROR_TOO_MANY_UNIQUE_STATE_OBJECTS                                : return "The application has exceeded the maximum number of unique state objects per Direct3D device";
    case D3D10_ERROR_FILE_NOT_FOUND                                               : return "The specified file was not found";
    case D3D11_ERROR_TOO_MANY_UNIQUE_STATE_OBJECTS                                : return "The application has exceeded the maximum number of unique state objects per Direct3D device";
    case D3D11_ERROR_FILE_NOT_FOUND                                               : return "The specified file was not found";
    case D3D11_ERROR_TOO_MANY_UNIQUE_VIEW_OBJECTS                                 : return "The application has exceeded the maximum number of unique view objects per Direct3D device";
    case D3D11_ERROR_DEFERRED_CONTEXT_MAP_WITHOUT_INITIAL_DISCARD                 : return "The application's first call per command list to Map on a deferred context did not use D3D11_MAP_WRITE_DISCARD";
    case D3D12_ERROR_ADAPTER_NOT_FOUND                                            : return "The blob provided does not match the adapter that the device was created on";
    case D3D12_ERROR_DRIVER_VERSION_MISMATCH                                      : return "The blob provided was created for a different version of the driver, and must be re-created";
    case D2DERR_WRONG_STATE                                                       : return "The object was not in the correct state to process the method";
    case D2DERR_NOT_INITIALIZED                                                   : return "The object has not yet been initialized";
    case D2DERR_UNSUPPORTED_OPERATION                                             : return "The requested operation is not supported";
    case D2DERR_SCANNER_FAILED                                                    : return "The geometry scanner failed to process the data";
    case D2DERR_SCREEN_ACCESS_DENIED                                              : return "Direct2D could not access the screen";
    case D2DERR_DISPLAY_STATE_INVALID                                             : return "A valid display state could not be determined";
    case D2DERR_ZERO_VECTOR                                                       : return "The supplied vector is zero";
    case D2DERR_INTERNAL_ERROR                                                    : return "An internal error (Direct2D bug) occurred. On checked builds, we would assert. The application should close this instance of Direct2D and should consider restarting its process";
    case D2DERR_DISPLAY_FORMAT_NOT_SUPPORTED                                      : return "The display format Direct2D needs to render is not supported by the hardware device";
    case D2DERR_INVALID_CALL                                                      : return "A call to this method is invalid";
    case D2DERR_NO_HARDWARE_DEVICE                                                : return "No hardware rendering device is available for this operation";
    case D2DERR_RECREATE_TARGET                                                   : return "There has been a presentation error that may be recoverable. The caller needs to recreate, rerender the entire frame, and reattempt present";
    case D2DERR_TOO_MANY_SHADER_ELEMENTS                                          : return "Shader construction failed because it was too complex";
    case D2DERR_SHADER_COMPILE_FAILED                                             : return "Shader compilation failed";
    case D2DERR_MAX_TEXTURE_SIZE_EXCEEDED                                         : return "Requested DirectX surface size exceeded maximum texture size";
    case D2DERR_UNSUPPORTED_VERSION                                               : return "The requested Direct2D version is not supported";
    case D2DERR_BAD_NUMBER                                                        : return "Invalid number";
    case D2DERR_WRONG_FACTORY                                                     : return "Objects used together must be created from the same factory instance";
    case D2DERR_LAYER_ALREADY_IN_USE                                              : return "A layer resource can only be in use once at any point in time";
    case D2DERR_POP_CALL_DID_NOT_MATCH_PUSH                                       : return "The pop call did not match the corresponding push call";
    case D2DERR_WRONG_RESOURCE_DOMAIN                                             : return "The resource was realized on the wrong render target";
    case D2DERR_PUSH_POP_UNBALANCED                                               : return "The push and pop calls were unbalanced";
    case D2DERR_RENDER_TARGET_HAS_LAYER_OR_CLIPRECT                               : return "Attempt to copy from a render target while a layer or clip rect is applied";
    case D2DERR_INCOMPATIBLE_BRUSH_TYPES                                          : return "The brush types are incompatible for the call";
    case D2DERR_WIN32_ERROR                                                       : return "An unknown win32 failure occurred";
    case D2DERR_TARGET_NOT_GDI_COMPATIBLE                                         : return "The render target is not compatible with GDI";
    case D2DERR_TEXT_EFFECT_IS_WRONG_TYPE                                         : return "A text client drawing effect object is of the wrong type";
    case D2DERR_TEXT_RENDERER_NOT_RELEASED                                        : return "The application is holding a reference to the IDWriteTextRenderer interface after the corresponding DrawText or DrawTextLayout call has returned. The IDWriteTextRenderer instance will be invalid";
    case D2DERR_EXCEEDS_MAX_BITMAP_SIZE                                           : return "The requested size is larger than the guaranteed supported texture size at the Direct3D device's current feature level";
    case D2DERR_INVALID_GRAPH_CONFIGURATION                                       : return "There was a configuration error in the graph";
    case D2DERR_INVALID_INTERNAL_GRAPH_CONFIGURATION                              : return "There was a internal configuration error in the graph";
    case D2DERR_CYCLIC_GRAPH                                                      : return "There was a cycle in the graph";
    case D2DERR_BITMAP_CANNOT_DRAW                                                : return "Cannot draw with a bitmap that has the D2D1_BITMAP_OPTIONS_CANNOT_DRAW option";
    case D2DERR_OUTSTANDING_BITMAP_REFERENCES                                     : return "The operation cannot complete while there are outstanding references to the target bitmap";
    case D2DERR_ORIGINAL_TARGET_NOT_BOUND                                         : return "The operation failed because the original target is not currently bound as a target";
    case D2DERR_INVALID_TARGET                                                    : return "Cannot set the image as a target because it is either an effect or is a bitmap that does not have the D2D1_BITMAP_OPTIONS_TARGET flag set";
    case D2DERR_BITMAP_BOUND_AS_TARGET                                            : return "Cannot draw with a bitmap that is currently bound as the target bitmap";
    case D2DERR_INSUFFICIENT_DEVICE_CAPABILITIES                                  : return "D3D Device does not have sufficient capabilities to perform the requested action";
    case D2DERR_INTERMEDIATE_TOO_LARGE                                            : return "The graph could not be rendered with the context's current tiling settings";
    case D2DERR_EFFECT_IS_NOT_REGISTERED                                          : return "The CLSID provided to Unregister did not correspond to a registered effect";
    case D2DERR_INVALID_PROPERTY                                                  : return "The specified property does not exist";
    case D2DERR_NO_SUBPROPERTIES                                                  : return "The specified sub-property does not exist";
    case D2DERR_PRINT_JOB_CLOSED                                                  : return "AddPage or Close called after print job is already closed";
    case D2DERR_PRINT_FORMAT_NOT_SUPPORTED                                        : return "Error during print control creation. Indicates that none of the package target types (representing printer formats) are supported by Direct2D print control";
    case D2DERR_TOO_MANY_TRANSFORM_INPUTS                                         : return "An effect attempted to use a transform with too many inputs";
    case D2DERR_INVALID_GLYPH_IMAGE                                               : return "An error was encountered while decoding or parsing the requested glyph image";
    case DWRITE_E_FILEFORMAT                                                      : return "Indicates an error in an input file such as a font file";
    case DWRITE_E_UNEXPECTED                                                      : return "Indicates an error originating in DirectWrite code, which is not expected to occur but is safe to recover from";
    case DWRITE_E_NOFONT                                                          : return "Indicates the specified font does not exist";
    case DWRITE_E_FILENOTFOUND                                                    : return "A font file could not be opened because the file, directory, network location, drive, or other storage location does not exist or is unavailable";
    case DWRITE_E_FILEACCESS                                                      : return "A font file exists but could not be opened due to access denied, sharing violation, or similar error";
    case DWRITE_E_FONTCOLLECTIONOBSOLETE                                          : return "A font collection is obsolete due to changes in the system";
    case DWRITE_E_ALREADYREGISTERED                                               : return "The given interface is already registered";
    case DWRITE_E_CACHEFORMAT                                                     : return "The font cache contains invalid data";
    case DWRITE_E_CACHEVERSION                                                    : return "A font cache file corresponds to a different version of DirectWrite";
    case DWRITE_E_UNSUPPORTEDOPERATION                                            : return "The operation is not supported for this type of font";
    case DWRITE_E_TEXTRENDERERINCOMPATIBLE                                        : return "The version of the text renderer interface is not compatible";
    case DWRITE_E_FLOWDIRECTIONCONFLICTS                                          : return "The flow direction conflicts with the reading direction. They must be perpendicular to each other";
    case DWRITE_E_NOCOLOR                                                         : return "The font or glyph run does not contain any colored glyphs";
    case DWRITE_E_REMOTEFONT                                                      : return "A font resource could not be accessed because it is remote";
    case DWRITE_E_DOWNLOADCANCELLED                                               : return "A font download was canceled";
    case DWRITE_E_DOWNLOADFAILED                                                  : return "A font download failed";
    case DWRITE_E_TOOMANYDOWNLOADS                                                : return "A font download request was not added or a download failed because there are too many active downloads";
    case WINCODEC_ERR_WRONGSTATE                                                  : return "The codec is in the wrong state";
    case WINCODEC_ERR_VALUEOUTOFRANGE                                             : return "The value is out of range";
    case WINCODEC_ERR_UNKNOWNIMAGEFORMAT                                          : return "The image format is unknown";
    case WINCODEC_ERR_UNSUPPORTEDVERSION                                          : return "The SDK version is unsupported";
    case WINCODEC_ERR_NOTINITIALIZED                                              : return "The component is not initialized";
    case WINCODEC_ERR_ALREADYLOCKED                                               : return "There is already an outstanding read or write lock";
    case WINCODEC_ERR_PROPERTYNOTFOUND                                            : return "The specified bitmap property cannot be found";
    case WINCODEC_ERR_PROPERTYNOTSUPPORTED                                        : return "The bitmap codec does not support the bitmap property";
    case WINCODEC_ERR_PROPERTYSIZE                                                : return "The bitmap property size is invalid";
    case WINCODEC_ERR_CODECPRESENT                                                : return "An unknown error has occurred";
    case WINCODEC_ERR_CODECNOTHUMBNAIL                                            : return "The bitmap codec does not support a thumbnail";
    case WINCODEC_ERR_PALETTEUNAVAILABLE                                          : return "The bitmap palette is unavailable";
    case WINCODEC_ERR_CODECTOOMANYSCANLINES                                       : return "Too many scanlines were requested";
    case WINCODEC_ERR_INTERNALERROR                                               : return "An internal error occurred";
    case WINCODEC_ERR_SOURCERECTDOESNOTMATCHDIMENSIONS                            : return "The bitmap bounds do not match the bitmap dimensions";
    case WINCODEC_ERR_COMPONENTNOTFOUND                                           : return "The component cannot be found";
    case WINCODEC_ERR_IMAGESIZEOUTOFRANGE                                         : return "The bitmap size is outside the valid range";
    case WINCODEC_ERR_TOOMUCHMETADATA                                             : return "There is too much metadata to be written to the bitmap";
    case WINCODEC_ERR_BADIMAGE                                                    : return "The image is unrecognized";
    case WINCODEC_ERR_BADHEADER                                                   : return "The image header is unrecognized";
    case WINCODEC_ERR_FRAMEMISSING                                                : return "The bitmap frame is missing";
    case WINCODEC_ERR_BADMETADATAHEADER                                           : return "The image metadata header is unrecognized";
    case WINCODEC_ERR_BADSTREAMDATA                                               : return "The stream data is unrecognized";
    case WINCODEC_ERR_STREAMWRITE                                                 : return "Failed to write to the stream";
    case WINCODEC_ERR_STREAMREAD                                                  : return "Failed to read from the stream";
    case WINCODEC_ERR_STREAMNOTAVAILABLE                                          : return "The stream is not available";
    case WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT                                      : return "The bitmap pixel format is unsupported";
    case WINCODEC_ERR_UNSUPPORTEDOPERATION                                        : return "The operation is unsupported";
    case WINCODEC_ERR_INVALIDREGISTRATION                                         : return "The component registration is invalid";
    case WINCODEC_ERR_COMPONENTINITIALIZEFAILURE                                  : return "The component initialization has failed";
    case WINCODEC_ERR_INSUFFICIENTBUFFER                                          : return "The buffer allocated is insufficient";
    case WINCODEC_ERR_DUPLICATEMETADATAPRESENT                                    : return "Duplicate metadata is present";
    case WINCODEC_ERR_PROPERTYUNEXPECTEDTYPE                                      : return "The bitmap property type is unexpected";
    case WINCODEC_ERR_UNEXPECTEDSIZE                                              : return "The size is unexpected";
    case WINCODEC_ERR_INVALIDQUERYREQUEST                                         : return "The property query is invalid";
    case WINCODEC_ERR_UNEXPECTEDMETADATATYPE                                      : return "The metadata type is unexpected";
    case WINCODEC_ERR_REQUESTONLYVALIDATMETADATAROOT                              : return "The specified bitmap property is only valid at root level";
    case WINCODEC_ERR_INVALIDQUERYCHARACTER                                       : return "The query string contains an invalid character";
    case WINCODEC_ERR_WIN32ERROR                                                  : return "Windows Codecs received an error from the Win32 system";
    case WINCODEC_ERR_INVALIDPROGRESSIVELEVEL                                     : return "The requested level of detail is not present";
    case WINCODEC_ERR_INVALIDJPEGSCANINDEX                                        : return "The scan index is invalid";
    case MILERR_OBJECTBUSY                                                        : return "MILERR_OBJECTBUSY";
    case MILERR_INSUFFICIENTBUFFER                                                : return "MILERR_INSUFFICIENTBUFFER";
    case MILERR_WIN32ERROR                                                        : return "MILERR_WIN32ERROR";
    case MILERR_SCANNER_FAILED                                                    : return "MILERR_SCANNER_FAILED";
    case MILERR_SCREENACCESSDENIED                                                : return "MILERR_SCREENACCESSDENIED";
    case MILERR_DISPLAYSTATEINVALID                                               : return "MILERR_DISPLAYSTATEINVALID";
    case MILERR_NONINVERTIBLEMATRIX                                               : return "MILERR_NONINVERTIBLEMATRIX";
    case MILERR_ZEROVECTOR                                                        : return "MILERR_ZEROVECTOR";
    case MILERR_TERMINATED                                                        : return "MILERR_TERMINATED";
    case MILERR_BADNUMBER                                                         : return "MILERR_BADNUMBER";
    case MILERR_INTERNALERROR                                                     : return "An internal error (MIL bug) occurred. On checked builds, an assert would be raised";
    case MILERR_DISPLAYFORMATNOTSUPPORTED                                         : return "The display format we need to render is not supported by the hardware device";
    case MILERR_INVALIDCALL                                                       : return "A call to this method is invalid";
    case MILERR_ALREADYLOCKED                                                     : return "Lock attempted on an already locked object";
    case MILERR_NOTLOCKED                                                         : return "Unlock attempted on an unlocked object";
    case MILERR_DEVICECANNOTRENDERTEXT                                            : return "No algorithm avaliable to render text with this device";
    case MILERR_GLYPHBITMAPMISSED                                                 : return "Some glyph bitmaps, required for glyph run rendering, are not contained in glyph cache";
    case MILERR_MALFORMEDGLYPHCACHE                                               : return "Some glyph bitmaps in glyph cache are unexpectedly big";
    case MILERR_GENERIC_IGNORE                                                    : return "Marker error for known Win32 errors that are currently being ignored by the compositor. This is to avoid returning S_OK when an error has occurred, but still unwind the stack in the correct location";
    case MILERR_MALFORMED_GUIDELINE_DATA                                          : return "Guideline coordinates are not sorted properly or contain NaNs";
    case MILERR_NO_HARDWARE_DEVICE                                                : return "No HW rendering device is available for this operation";
    case MILERR_NEED_RECREATE_AND_PRESENT                                         : return "There has been a presentation error that may be recoverable. The caller needs to recreate, rerender the entire frame, and reattempt present";
    case MILERR_ALREADY_INITIALIZED                                               : return "The object has already been initialized";
    case MILERR_MISMATCHED_SIZE                                                   : return "The size of the object does not match the expected size";
    case MILERR_NO_REDIRECTION_SURFACE_AVAILABLE                                  : return "No Redirection surface available";
    case MILERR_REMOTING_NOT_SUPPORTED                                            : return "Remoting of this content is not supported";
    case MILERR_QUEUED_PRESENT_NOT_SUPPORTED                                      : return "Queued Presents are not supported";
    case MILERR_NOT_QUEUING_PRESENTS                                              : return "Queued Presents are not being used";
    case MILERR_NO_REDIRECTION_SURFACE_RETRY_LATER                                : return "No redirection surface was available. Caller should retry the call";
    case MILERR_TOOMANYSHADERELEMNTS                                              : return "Shader construction failed because it was too complex";
    case MILERR_MROW_READLOCK_FAILED                                              : return "MROW attempt to get a read lock failed";
    case MILERR_MROW_UPDATE_FAILED                                                : return "MROW attempt to update the data failed because another update was outstanding";
    case MILERR_SHADER_COMPILE_FAILED                                             : return "Shader compilation failed";
    case MILERR_MAX_TEXTURE_SIZE_EXCEEDED                                         : return "Requested DX redirection surface size exceeded maximum texture size";
    case MILERR_QPC_TIME_WENT_BACKWARD                                            : return "QueryPerformanceCounter returned a time in the past";
    case MILERR_DXGI_ENUMERATION_OUT_OF_SYNC                                      : return "Primary Display device returned an invalid refresh rate";
    case MILERR_ADAPTER_NOT_FOUND                                                 : return "DWM can not find the adapter specified by the LUID";
    case MILERR_COLORSPACE_NOT_SUPPORTED                                          : return "The requested bitmap color space is not supported";
    case MILERR_PREFILTER_NOT_SUPPORTED                                           : return "The requested bitmap pre-filtering state is not supported";
    case MILERR_DISPLAYID_ACCESS_DENIED                                           : return "Access is denied to the requested bitmap for the specified display id";
    case UCEERR_INVALIDPACKETHEADER                                               : return "UCEERR_INVALIDPACKETHEADER";
    case UCEERR_UNKNOWNPACKET                                                     : return "UCEERR_UNKNOWNPACKET";
    case UCEERR_ILLEGALPACKET                                                     : return "UCEERR_ILLEGALPACKET";
    case UCEERR_MALFORMEDPACKET                                                   : return "UCEERR_MALFORMEDPACKET";
    case UCEERR_ILLEGALHANDLE                                                     : return "UCEERR_ILLEGALHANDLE";
    case UCEERR_HANDLELOOKUPFAILED                                                : return "UCEERR_HANDLELOOKUPFAILED";
    case UCEERR_RENDERTHREADFAILURE                                               : return "UCEERR_RENDERTHREADFAILURE";
    case UCEERR_CTXSTACKFRSTTARGETNULL                                            : return "UCEERR_CTXSTACKFRSTTARGETNULL";
    case UCEERR_CONNECTIONIDLOOKUPFAILED                                          : return "UCEERR_CONNECTIONIDLOOKUPFAILED";
    case UCEERR_BLOCKSFULL                                                        : return "UCEERR_BLOCKSFULL";
    case UCEERR_MEMORYFAILURE                                                     : return "UCEERR_MEMORYFAILURE";
    case UCEERR_PACKETRECORDOUTOFRANGE                                            : return "UCEERR_PACKETRECORDOUTOFRANGE";
    case UCEERR_ILLEGALRECORDTYPE                                                 : return "UCEERR_ILLEGALRECORDTYPE";
    case UCEERR_OUTOFHANDLES                                                      : return "UCEERR_OUTOFHANDLES";
    case UCEERR_UNCHANGABLE_UPDATE_ATTEMPTED                                      : return "UCEERR_UNCHANGABLE_UPDATE_ATTEMPTED";
    case UCEERR_NO_MULTIPLE_WORKER_THREADS                                        : return "UCEERR_NO_MULTIPLE_WORKER_THREADS";
    case UCEERR_REMOTINGNOTSUPPORTED                                              : return "UCEERR_REMOTINGNOTSUPPORTED";
    case UCEERR_MISSINGENDCOMMAND                                                 : return "UCEERR_MISSINGENDCOMMAND";
    case UCEERR_MISSINGBEGINCOMMAND                                               : return "UCEERR_MISSINGBEGINCOMMAND";
    case UCEERR_CHANNELSYNCTIMEDOUT                                               : return "UCEERR_CHANNELSYNCTIMEDOUT";
    case UCEERR_CHANNELSYNCABANDONED                                              : return "UCEERR_CHANNELSYNCABANDONED";
    case UCEERR_UNSUPPORTEDTRANSPORTVERSION                                       : return "UCEERR_UNSUPPORTEDTRANSPORTVERSION";
    case UCEERR_TRANSPORTUNAVAILABLE                                              : return "UCEERR_TRANSPORTUNAVAILABLE";
    case UCEERR_FEEDBACK_UNSUPPORTED                                              : return "UCEERR_FEEDBACK_UNSUPPORTED";
    case UCEERR_COMMANDTRANSPORTDENIED                                            : return "UCEERR_COMMANDTRANSPORTDENIED";
    case UCEERR_GRAPHICSSTREAMUNAVAILABLE                                         : return "UCEERR_GRAPHICSSTREAMUNAVAILABLE";
    case UCEERR_GRAPHICSSTREAMALREADYOPEN                                         : return "UCEERR_GRAPHICSSTREAMALREADYOPEN";
    case UCEERR_TRANSPORTDISCONNECTED                                             : return "UCEERR_TRANSPORTDISCONNECTED";
    case UCEERR_TRANSPORTOVERLOADED                                               : return "UCEERR_TRANSPORTOVERLOADED";
    case UCEERR_PARTITION_ZOMBIED                                                 : return "UCEERR_PARTITION_ZOMBIED";
    case MILAVERR_NOCLOCK                                                         : return "MILAVERR_NOCLOCK";
    case MILAVERR_NOMEDIATYPE                                                     : return "MILAVERR_NOMEDIATYPE";
    case MILAVERR_NOVIDEOMIXER                                                    : return "MILAVERR_NOVIDEOMIXER";
    case MILAVERR_NOVIDEOPRESENTER                                                : return "MILAVERR_NOVIDEOPRESENTER";
    case MILAVERR_NOREADYFRAMES                                                   : return "MILAVERR_NOREADYFRAMES";
    case MILAVERR_MODULENOTLOADED                                                 : return "MILAVERR_MODULENOTLOADED";
    case MILAVERR_WMPFACTORYNOTREGISTERED                                         : return "MILAVERR_WMPFACTORYNOTREGISTERED";
    case MILAVERR_INVALIDWMPVERSION                                               : return "MILAVERR_INVALIDWMPVERSION";
    case MILAVERR_INSUFFICIENTVIDEORESOURCES                                      : return "MILAVERR_INSUFFICIENTVIDEORESOURCES";
    case MILAVERR_VIDEOACCELERATIONNOTAVAILABLE                                   : return "MILAVERR_VIDEOACCELERATIONNOTAVAILABLE";
    case MILAVERR_REQUESTEDTEXTURETOOBIG                                          : return "MILAVERR_REQUESTEDTEXTURETOOBIG";
    case MILAVERR_SEEKFAILED                                                      : return "MILAVERR_SEEKFAILED";
    case MILAVERR_UNEXPECTEDWMPFAILURE                                            : return "MILAVERR_UNEXPECTEDWMPFAILURE";
    case MILAVERR_MEDIAPLAYERCLOSED                                               : return "MILAVERR_MEDIAPLAYERCLOSED";
    case MILAVERR_UNKNOWNHARDWAREERROR                                            : return "MILAVERR_UNKNOWNHARDWAREERROR";
    case MILEFFECTSERR_UNKNOWNPROPERTY                                            : return "MILEFFECTSERR_UNKNOWNPROPERTY";
    case MILEFFECTSERR_EFFECTNOTPARTOFGROUP                                       : return "MILEFFECTSERR_EFFECTNOTPARTOFGROUP";
    case MILEFFECTSERR_NOINPUTSOURCEATTACHED                                      : return "MILEFFECTSERR_NOINPUTSOURCEATTACHED";
    case MILEFFECTSERR_CONNECTORNOTCONNECTED                                      : return "MILEFFECTSERR_CONNECTORNOTCONNECTED";
    case MILEFFECTSERR_CONNECTORNOTASSOCIATEDWITHEFFECT                           : return "MILEFFECTSERR_CONNECTORNOTASSOCIATEDWITHEFFECT";
    case MILEFFECTSERR_RESERVED                                                   : return "MILEFFECTSERR_RESERVED";
    case MILEFFECTSERR_CYCLEDETECTED                                              : return "MILEFFECTSERR_CYCLEDETECTED";
    case MILEFFECTSERR_EFFECTINMORETHANONEGRAPH                                   : return "MILEFFECTSERR_EFFECTINMORETHANONEGRAPH";
    case MILEFFECTSERR_EFFECTALREADYINAGRAPH                                      : return "MILEFFECTSERR_EFFECTALREADYINAGRAPH";
    case MILEFFECTSERR_EFFECTHASNOCHILDREN                                        : return "MILEFFECTSERR_EFFECTHASNOCHILDREN";
    case MILEFFECTSERR_ALREADYATTACHEDTOLISTENER                                  : return "MILEFFECTSERR_ALREADYATTACHEDTOLISTENER";
    case MILEFFECTSERR_NOTAFFINETRANSFORM                                         : return "MILEFFECTSERR_NOTAFFINETRANSFORM";
    case MILEFFECTSERR_EMPTYBOUNDS                                                : return "MILEFFECTSERR_EMPTYBOUNDS";
    case MILEFFECTSERR_OUTPUTSIZETOOLARGE                                         : return "MILEFFECTSERR_OUTPUTSIZETOOLARGE";
    case DWMERR_STATE_TRANSITION_FAILED                                           : return "DWMERR_STATE_TRANSITION_FAILED";
    case DWMERR_THEME_FAILED                                                      : return "DWMERR_THEME_FAILED";
    case DWMERR_CATASTROPHIC_FAILURE                                              : return "DWMERR_CATASTROPHIC_FAILURE";
    case DCOMPOSITION_ERROR_WINDOW_ALREADY_COMPOSED                               : return "DCOMPOSITION_ERROR_WINDOW_ALREADY_COMPOSED";
    case DCOMPOSITION_ERROR_SURFACE_BEING_RENDERED                                : return "DCOMPOSITION_ERROR_SURFACE_BEING_RENDERED";
    case DCOMPOSITION_ERROR_SURFACE_NOT_BEING_RENDERED                            : return "DCOMPOSITION_ERROR_SURFACE_NOT_BEING_RENDERED";
    case ONL_E_INVALID_AUTHENTICATION_TARGET                                      : return "Authentication target is invalid or not configured correctly";
    case ONL_E_ACCESS_DENIED_BY_TOU                                               : return "Your application cannot get the Online Id properties due to the Terms of Use accepted by the user";
    case ONL_E_INVALID_APPLICATION                                                : return "The application requesting authentication tokens is either disabled or incorrectly configured";
    case ONL_E_PASSWORD_UPDATE_REQUIRED                                           : return "Online Id password must be updated before signin";
    case ONL_E_ACCOUNT_UPDATE_REQUIRED                                            : return "Online Id account properties must be updated before signin";
    case ONL_E_FORCESIGNIN                                                        : return "To help protect your Online Id account you must signin again";
    case ONL_E_ACCOUNT_LOCKED                                                     : return "Online Id account was locked because there have been too many attempts to sign in";
    case ONL_E_PARENTAL_CONSENT_REQUIRED                                          : return "Online Id account requires parental consent before proceeding";
    case ONL_E_EMAIL_VERIFICATION_REQUIRED                                        : return "Online Id signin name is not yet verified. Email verification is required before signin";
    case ONL_E_ACCOUNT_SUSPENDED_COMPROIMISE                                      : return "We have noticed some unusual activity in your Online Id account. Your action is needed to make sure no one else is using your account";
    case ONL_E_ACCOUNT_SUSPENDED_ABUSE                                            : return "We detected some suspicious activity with your Online Id account. To help protect you, we've temporarily blocked your account";
    case ONL_E_ACTION_REQUIRED                                                    : return "User interaction is required for authentication";
    case ONL_CONNECTION_COUNT_LIMIT                                               : return "User has reached the maximum device associations per user limit";
    case ONL_E_CONNECTED_ACCOUNT_CAN_NOT_SIGNOUT                                  : return "Cannot sign out from the application since the user account is connected";
    case ONL_E_USER_AUTHENTICATION_REQUIRED                                       : return "User authentication is required for this operation";
    case ONL_E_REQUEST_THROTTLED                                                  : return "We want to make sure this is you. User interaction is required for authentication";
    case FA_E_MAX_PERSISTED_ITEMS_REACHED                                         : return "The maximum number of items for the access list has been reached. An item must be removed before another item is added";
    case FA_E_HOMEGROUP_NOT_AVAILABLE                                             : return "Cannot access Homegroup. Homegroup may not be set up or may have encountered an error";
    case E_MONITOR_RESOLUTION_TOO_LOW                                             : return "This app can't start because the screen resolution is below 1024x768. Choose a higher screen resolution and then try again";
    case E_ELEVATED_ACTIVATION_NOT_SUPPORTED                                      : return "This app can't be activated from an elevated context";
    case E_UAC_DISABLED                                                           : return "This app can't be activated when UAC is disabled";
    case E_FULL_ADMIN_NOT_SUPPORTED                                               : return "This app can't be activated by the Built-in Administrator";
    case E_APPLICATION_NOT_REGISTERED                                             : return "This app does not support the contract specified or is not installed";
    case E_MULTIPLE_EXTENSIONS_FOR_APPLICATION                                    : return "This app has mulitple extensions registered to support the specified contract. Activation by AppUserModelId is ambiguous";
    case E_MULTIPLE_PACKAGES_FOR_FAMILY                                           : return "This app's package family has more than one package installed. This is not supported";
    case E_APPLICATION_MANAGER_NOT_RUNNING                                        : return "The app manager is required to activate applications, but is not running";
    case S_STORE_LAUNCHED_FOR_REMEDIATION                                         : return "The Store was launched instead of the specified app because the app's package was in an invalid state";
    case S_APPLICATION_ACTIVATION_ERROR_HANDLED_BY_DIALOG                         : return "This app failed to launch, but the error was handled with a dialog";
    case E_APPLICATION_ACTIVATION_TIMED_OUT                                       : return "The app didn't start in the required time";
    case E_APPLICATION_ACTIVATION_EXEC_FAILURE                                    : return "The app didn't start";
    case E_APPLICATION_TEMPORARY_LICENSE_ERROR                                    : return "This app failed to launch because of an issue with its license. Please try again in a moment";
    case E_APPLICATION_TRIAL_LICENSE_EXPIRED                                      : return "This app failed to launch because its trial license has expired";
    case E_SKYDRIVE_ROOT_TARGET_FILE_SYSTEM_NOT_SUPPORTED                         : return "Please choose a folder on a drive that's formatted with the NTFS file system";
    case E_SKYDRIVE_ROOT_TARGET_OVERLAP                                           : return "This location is already being used. Please choose a different location";
    case E_SKYDRIVE_ROOT_TARGET_CANNOT_INDEX                                      : return "This location cannot be indexed. Please choose a different location";
    case E_SKYDRIVE_FILE_NOT_UPLOADED                                             : return "Sorry, the action couldn't be completed because the file hasn't finished uploading. Try again later";
    case E_SKYDRIVE_UPDATE_AVAILABILITY_FAIL                                      : return "Sorry, the action couldn't be completed";
    case E_SKYDRIVE_ROOT_TARGET_VOLUME_ROOT_NOT_SUPPORTED                         : return "This content can only be moved to a folder. To move the content to this drive, please choose or create a folder";
    case E_SYNCENGINE_FILE_SIZE_OVER_LIMIT                                        : return "The file size is larger than supported by the sync engine";
    case E_SYNCENGINE_FILE_SIZE_EXCEEDS_REMAINING_QUOTA                           : return "The file cannot be uploaded because it doesn't fit in the user's available service provided storage space";
    case E_SYNCENGINE_UNSUPPORTED_FILE_NAME                                       : return "The file name contains invalid characters";
    case E_SYNCENGINE_FOLDER_ITEM_COUNT_LIMIT_EXCEEDED                            : return "The maximum file count has been reached for this folder in the sync engine";
    case E_SYNCENGINE_FILE_SYNC_PARTNER_ERROR                                     : return "The file sync has been delegated to another program and has run into an issue";
    case E_SYNCENGINE_SYNC_PAUSED_BY_SERVICE                                      : return "Sync has been delayed due to a throttling request from the service";
    case E_SYNCENGINE_FILE_IDENTIFIER_UNKNOWN                                     : return "We can't seem to find that file. Please try again later";
    case E_SYNCENGINE_SERVICE_AUTHENTICATION_FAILED                               : return "The account you're signed in with doesn't have permission to open this file";
    case E_SYNCENGINE_UNKNOWN_SERVICE_ERROR                                       : return "There was a problem connecting to the service. Please try again later";
    case E_SYNCENGINE_SERVICE_RETURNED_UNEXPECTED_SIZE                            : return "Sorry, there was a problem downloading the file";
    case E_SYNCENGINE_REQUEST_BLOCKED_BY_SERVICE                                  : return "We're having trouble downloading the file right now. Please try again later";
    case E_SYNCENGINE_REQUEST_BLOCKED_DUE_TO_CLIENT_ERROR                         : return "We're having trouble downloading the file right now. Please try again later";
    case E_SYNCENGINE_FOLDER_INACCESSIBLE                                         : return "The sync engine does not have permissions to access a local folder under the sync root";
    case E_SYNCENGINE_UNSUPPORTED_FOLDER_NAME                                     : return "The folder name contains invalid characters";
    case E_SYNCENGINE_UNSUPPORTED_MARKET                                          : return "The sync engine is not allowed to run in your current market";
    case E_SYNCENGINE_PATH_LENGTH_LIMIT_EXCEEDED                                  : return "All files and folders can't be uploaded because a path of a file or folder is too long";
    case E_SYNCENGINE_REMOTE_PATH_LENGTH_LIMIT_EXCEEDED                           : return "All file and folders cannot be synchronized because a path of a file or folder would exceed the local path limit";
    case E_SYNCENGINE_CLIENT_UPDATE_NEEDED                                        : return "Updates are needed in order to use the sync engine";
    case E_SYNCENGINE_PROXY_AUTHENTICATION_REQUIRED                               : return "The sync engine needs to authenticate with a proxy server";
    case E_SYNCENGINE_STORAGE_SERVICE_PROVISIONING_FAILED                         : return "There was a problem setting up the storage services for the account";
    case E_SYNCENGINE_UNSUPPORTED_REPARSE_POINT                                   : return "Files can't be uploaded because there's an unsupported reparse point";
    case E_SYNCENGINE_STORAGE_SERVICE_BLOCKED                                     : return "The service has blocked your account from accessing the storage service";
    case E_SYNCENGINE_FOLDER_IN_REDIRECTION                                       : return "The action can't be performed right now because this folder is being moved. Please try again later";
    case EAS_E_POLICY_NOT_MANAGED_BY_OS                                           : return "Windows cannot evaluate this EAS policy since this is not managed by the operating system";
    case EAS_E_POLICY_COMPLIANT_WITH_ACTIONS                                      : return "The system can be made compliant to this EAS policy if certain actions are performed by the user";
    case EAS_E_REQUESTED_POLICY_NOT_ENFORCEABLE                                   : return "The EAS policy being evaluated cannot be enforced by the system";
    case EAS_E_CURRENT_USER_HAS_BLANK_PASSWORD                                    : return "EAS password policies for the user cannot be evaluated as the user has a blank password";
    case EAS_E_REQUESTED_POLICY_PASSWORD_EXPIRATION_INCOMPATIBLE                  : return "EAS password expiration policy cannot be satisfied as the password expiration interval is less than the minimum password interval of the system";
    case EAS_E_USER_CANNOT_CHANGE_PASSWORD                                        : return "The user is not allowed to change her password";
    case EAS_E_ADMINS_HAVE_BLANK_PASSWORD                                         : return "EAS password policies cannot be evaluated as one or more admins have blank passwords";
    case EAS_E_ADMINS_CANNOT_CHANGE_PASSWORD                                      : return "One or more admins are not allowed to change their password";
    case EAS_E_LOCAL_CONTROLLED_USERS_CANNOT_CHANGE_PASSWORD                      : return "There are other standard users present who are not allowed to change their password";
    case EAS_E_PASSWORD_POLICY_NOT_ENFORCEABLE_FOR_CONNECTED_ADMINS               : return "The EAS password policy cannot be enforced by the connected account provider of at least one administrator";
    case EAS_E_CONNECTED_ADMINS_NEED_TO_CHANGE_PASSWORD                           : return "There is at least one administrator whose connected account password needs to be changed for EAS password policy compliance";
    case EAS_E_PASSWORD_POLICY_NOT_ENFORCEABLE_FOR_CURRENT_CONNECTED_USER         : return "The EAS password policy cannot be enforced by the connected account provider of the current user";
    case EAS_E_CURRENT_CONNECTED_USER_NEED_TO_CHANGE_PASSWORD                     : return "The connected account password of the current user needs to be changed for EAS password policy compliance";
    case WEB_E_UNSUPPORTED_FORMAT                                                 : return "Unsupported format";
    case WEB_E_INVALID_XML                                                        : return "Invalid XML";
    case WEB_E_MISSING_REQUIRED_ELEMENT                                           : return "Missing required element";
    case WEB_E_MISSING_REQUIRED_ATTRIBUTE                                         : return "Missing required attribute";
    case WEB_E_UNEXPECTED_CONTENT                                                 : return "Unexpected content";
    case WEB_E_RESOURCE_TOO_LARGE                                                 : return "Resource too large";
    case WEB_E_INVALID_JSON_STRING                                                : return "Invalid JSON string";
    case WEB_E_INVALID_JSON_NUMBER                                                : return "Invalid JSON number";
    case WEB_E_JSON_VALUE_NOT_FOUND                                               : return "JSON value not found";
    case HTTP_E_STATUS_UNEXPECTED                                                 : return "Unexpected HTTP status code";
    case HTTP_E_STATUS_UNEXPECTED_REDIRECTION                                     : return "Unexpected redirection status code (3xx)";
    case HTTP_E_STATUS_UNEXPECTED_CLIENT_ERROR                                    : return "Unexpected client error status code (4xx)";
    case HTTP_E_STATUS_UNEXPECTED_SERVER_ERROR                                    : return "Unexpected server error status code (5xx)";
    case HTTP_E_STATUS_AMBIGUOUS                                                  : return "Multiple choices (300)";
    case HTTP_E_STATUS_MOVED                                                      : return "Moved permanently (301)";
    case HTTP_E_STATUS_REDIRECT                                                   : return "Found (302)";
    case HTTP_E_STATUS_REDIRECT_METHOD                                            : return "See Other (303)";
    case HTTP_E_STATUS_NOT_MODIFIED                                               : return "Not modified (304)";
    case HTTP_E_STATUS_USE_PROXY                                                  : return "Use proxy (305)";
    case HTTP_E_STATUS_REDIRECT_KEEP_VERB                                         : return "Temporary redirect (307)";
    case HTTP_E_STATUS_BAD_REQUEST                                                : return "Bad request (400)";
    case HTTP_E_STATUS_DENIED                                                     : return "Unauthorized (401)";
    case HTTP_E_STATUS_PAYMENT_REQ                                                : return "Payment required (402)";
    case HTTP_E_STATUS_FORBIDDEN                                                  : return "Forbidden (403)";
    case HTTP_E_STATUS_NOT_FOUND                                                  : return "Not found (404)";
    case HTTP_E_STATUS_BAD_METHOD                                                 : return "Method not allowed (405)";
    case HTTP_E_STATUS_NONE_ACCEPTABLE                                            : return "Not acceptable (406)";
    case HTTP_E_STATUS_PROXY_AUTH_REQ                                             : return "Proxy authentication required (407)";
    case HTTP_E_STATUS_REQUEST_TIMEOUT                                            : return "Request timeout (408)";
    case HTTP_E_STATUS_CONFLICT                                                   : return "Conflict (409)";
    case HTTP_E_STATUS_GONE                                                       : return "Gone (410)";
    case HTTP_E_STATUS_LENGTH_REQUIRED                                            : return "Length required (411)";
    case HTTP_E_STATUS_PRECOND_FAILED                                             : return "Precondition failed (412)";
    case HTTP_E_STATUS_REQUEST_TOO_LARGE                                          : return "Request entity too large (413)";
    case HTTP_E_STATUS_URI_TOO_LONG                                               : return "Request-URI too long (414)";
    case HTTP_E_STATUS_UNSUPPORTED_MEDIA                                          : return "Unsupported media type (415)";
    case HTTP_E_STATUS_RANGE_NOT_SATISFIABLE                                      : return "Requested range not satisfiable (416)";
    case HTTP_E_STATUS_EXPECTATION_FAILED                                         : return "Expectation failed (417)";
    case HTTP_E_STATUS_SERVER_ERROR                                               : return "Internal server error (500)";
    case HTTP_E_STATUS_NOT_SUPPORTED                                              : return "Not implemented (501)";
    case HTTP_E_STATUS_BAD_GATEWAY                                                : return "Bad gateway (502)";
    case HTTP_E_STATUS_SERVICE_UNAVAIL                                            : return "Service unavailable (503)";
    case HTTP_E_STATUS_GATEWAY_TIMEOUT                                            : return "Gateway timeout (504)";
    case HTTP_E_STATUS_VERSION_NOT_SUP                                            : return "Version not supported (505)";
    case E_INVALID_PROTOCOL_OPERATION                                             : return "Invalid operation performed by the protocol";
    case E_INVALID_PROTOCOL_FORMAT                                                : return "Invalid data format for the specific protocol operation";
    case E_PROTOCOL_EXTENSIONS_NOT_SUPPORTED                                      : return "Protocol extensions are not supported";
    case E_SUBPROTOCOL_NOT_SUPPORTED                                              : return "Subrotocol is not supported";
    case E_PROTOCOL_VERSION_NOT_SUPPORTED                                         : return "Incorrect protocol version";
    case INPUT_E_OUT_OF_ORDER                                                     : return "Input data cannot be processed in the non-chronological order";
    case INPUT_E_REENTRANCY                                                       : return "Requested operation cannot be performed inside the callback or event handler";
    case INPUT_E_MULTIMODAL                                                       : return "Input cannot be processed because there is ongoing interaction with another pointer type";
    case INPUT_E_PACKET                                                           : return "One or more fields in the input packet are invalid";
    case INPUT_E_FRAME                                                            : return "Packets in the frame are inconsistent. Either pointer ids are not unique or there is a discrepancy in timestamps, frame ids, pointer types or source devices";
    case INPUT_E_HISTORY                                                          : return "The history of frames is inconsistent. Pointer ids, types, source devices don't match, or frame ids are not unique, or timestamps are out of order";
    case INPUT_E_DEVICE_INFO                                                      : return "Failed to retrieve information about the input device";
    case INPUT_E_TRANSFORM                                                        : return "Coordinate system transformation failed to transform the data";
    case INPUT_E_DEVICE_PROPERTY                                                  : return "The property is not supported or not reported correctly by the input device";
    case INET_E_INVALID_URL                                                       : return "The URL is invalid";
    case INET_E_NO_SESSION                                                        : return "No Internet session has been established";
    case INET_E_CANNOT_CONNECT                                                    : return "Unable to connect to the target server";
    case INET_E_RESOURCE_NOT_FOUND                                                : return "The system cannot locate the resource specified";
    case INET_E_OBJECT_NOT_FOUND                                                  : return "The system cannot locate the object specified";
    case INET_E_DATA_NOT_AVAILABLE                                                : return "No data is available for the requested resource";
    case INET_E_DOWNLOAD_FAILURE                                                  : return "The download of the specified resource has failed";
    case INET_E_AUTHENTICATION_REQUIRED                                           : return "Authentication is required to access this resource";
    case INET_E_NO_VALID_MEDIA                                                    : return "The server could not recognize the provided mime type";
    case INET_E_CONNECTION_TIMEOUT                                                : return "The operation was timed out";
    case INET_E_INVALID_REQUEST                                                   : return "The server did not understand the request, or the request was invalid";
    case INET_E_UNKNOWN_PROTOCOL                                                  : return "The specified protocol is unknown";
    case INET_E_SECURITY_PROBLEM                                                  : return "A security problem occurred";
    case INET_E_CANNOT_LOAD_DATA                                                  : return "The system could not load the persisted data";
    case INET_E_CANNOT_INSTANTIATE_OBJECT                                         : return "Unable to instantiate the object";
    case INET_E_INVALID_CERTIFICATE                                               : return "Security certificate required to access this resource is invalid";
    case INET_E_REDIRECT_FAILED                                                   : return "A redirection problem occurred";
    case INET_E_REDIRECT_TO_DIR                                                   : return "The requested resource is a directory, not a file";
    case ERROR_DBG_CREATE_PROCESS_FAILURE_LOCKDOWN                                : return "Could not create new process from ARM architecture device";
    case ERROR_DBG_ATTACH_PROCESS_FAILURE_LOCKDOWN                                : return "Could not attach to the application process from ARM architecture device";
    case ERROR_DBG_CONNECT_SERVER_FAILURE_LOCKDOWN                                : return "Could not connect to dbgsrv server from ARM architecture device";
    case ERROR_DBG_START_SERVER_FAILURE_LOCKDOWN                                  : return "Could not start dbgsrv server from ARM architecture device";
    case ERROR_IO_PREEMPTED                                                       : return "The operation was preempted by a higher priority operation. It must be resumed later";
    case JSCRIPT_E_CANTEXECUTE                                                    : return "Function could not execute because it was deleted or garbage collected";
    case WEP_E_NOT_PROVISIONED_ON_ALL_VOLUMES                                     : return "One or more fixed volumes are not provisioned with the 3rd party encryption providers to support device encryption. Enable encryption with the 3rd party provider to comply with policy";
    case WEP_E_FIXED_DATA_NOT_SUPPORTED                                           : return "This computer is not fully encrypted. There are fixed volumes present which are not supported for encryption";
    case WEP_E_HARDWARE_NOT_COMPLIANT                                             : return "This computer does not meet the hardware requirements to support device encryption with the installed 3rd party provider";
    case WEP_E_LOCK_NOT_CONFIGURED                                                : return "This computer cannot support device encryption because the requisites for the device lock feature are not configured";
    case WEP_E_PROTECTION_SUSPENDED                                               : return "Protection is enabled on this volume but is not in the active state";
    case WEP_E_NO_LICENSE                                                         : return "The 3rd party provider has been installed, but cannot activate encryption beacuse a license has not been activated";
    case WEP_E_OS_NOT_PROTECTED                                                   : return "The operating system drive is not protected by 3rd party drive encryption";
    case WEP_E_UNEXPECTED_FAIL                                                    : return "Unexpected failure was encountered while calling into the 3rd Party drive encryption plugin";
    case WEP_E_BUFFER_TOO_LARGE                                                   : return "The input buffer size for the lockout metadata used by the 3rd party drive encryption is too large";
    case ERROR_SVHDX_ERROR_STORED                                                 : return "The proper error code with sense data was stored on server side";
    case ERROR_SVHDX_ERROR_NOT_AVAILABLE                                          : return "The requested error data is not available on the server";
    case ERROR_SVHDX_UNIT_ATTENTION_AVAILABLE                                     : return "Unit Attention data is available for the initiator to query";
    case ERROR_SVHDX_UNIT_ATTENTION_CAPACITY_DATA_CHANGED                         : return "The data capacity of the device has changed, resulting in a Unit Attention condition";
    case ERROR_SVHDX_UNIT_ATTENTION_RESERVATIONS_PREEMPTED                        : return "A previous operation resulted in this initiator's reservations being preempted, resulting in a Unit Attention condition";
    case ERROR_SVHDX_UNIT_ATTENTION_RESERVATIONS_RELEASED                         : return "A previous operation resulted in this initiator's reservations being released, resulting in a Unit Attention condition";
    case ERROR_SVHDX_UNIT_ATTENTION_REGISTRATIONS_PREEMPTED                       : return "A previous operation resulted in this initiator's registrations being preempted, resulting in a Unit Attention condition";
    case ERROR_SVHDX_UNIT_ATTENTION_OPERATING_DEFINITION_CHANGED                  : return "The data storage format of the device has changed, resulting in a Unit Attention condition";
    case ERROR_SVHDX_RESERVATION_CONFLICT                                         : return "The current initiator is not allowed to perform the SCSI command because of a reservation conflict";
    case ERROR_SVHDX_WRONG_FILE_TYPE                                              : return "Multiple virtual machines sharing a virtual hard disk is supported only on Fixed or Dynamic VHDX format virtual hard disks";
    case ERROR_SVHDX_VERSION_MISMATCH                                             : return "The server version does not match the requested version";
    case ERROR_VHD_SHARED                                                         : return "The requested operation cannot be performed on the virtual disk as it is currently used in shared mode";
    case ERROR_SVHDX_NO_INITIATOR                                                 : return "Invalid Shared VHDX open due to lack of initiator ID. Check for related Continuous Availability failures";
    case ERROR_VHDSET_BACKING_STORAGE_NOT_FOUND                                   : return "The requested operation failed due to a missing backing storage file";
    case ERROR_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP                              : return "Failed to negotiate a preauthentication integrity hash function";
    case ERROR_SMB_BAD_CLUSTER_DIALECT                                            : return "The current cluster functional level does not support this SMB dialect";
    case WININET_E_OUT_OF_HANDLES                                                 : return "No more Internet handles can be allocated";
    case WININET_E_TIMEOUT                                                        : return "The operation timed out";
    case WININET_E_EXTENDED_ERROR                                                 : return "The server returned extended information";
    case WININET_E_INTERNAL_ERROR                                                 : return "An internal error occurred in the Microsoft Internet extensions";
    case WININET_E_INVALID_URL                                                    : return "The URL is invalid";
    case WININET_E_UNRECOGNIZED_SCHEME                                            : return "The URL does not use a recognized protocol";
    case WININET_E_NAME_NOT_RESOLVED                                              : return "The server name or address could not be resolved";
    case WININET_E_PROTOCOL_NOT_FOUND                                             : return "A protocol with the required capabilities was not found";
    case WININET_E_INVALID_OPTION                                                 : return "The option is invalid";
    case WININET_E_BAD_OPTION_LENGTH                                              : return "The length is incorrect for the option type";
    case WININET_E_OPTION_NOT_SETTABLE                                            : return "The option value cannot be set";
    case WININET_E_SHUTDOWN                                                       : return "Microsoft Internet Extension support has been shut down";
    case WININET_E_INCORRECT_USER_NAME                                            : return "The user name was not allowed";
    case WININET_E_INCORRECT_PASSWORD                                             : return "The password was not allowed";
    case WININET_E_LOGIN_FAILURE                                                  : return "The login request was denied";
    case WININET_E_INVALID_OPERATION                                              : return "The requested operation is invalid";
    case WININET_E_OPERATION_CANCELLED                                            : return "The operation has been canceled";
    case WININET_E_INCORRECT_HANDLE_TYPE                                          : return "The supplied handle is the wrong type for the requested operation";
    case WININET_E_INCORRECT_HANDLE_STATE                                         : return "The handle is in the wrong state for the requested operation";
    case WININET_E_NOT_PROXY_REQUEST                                              : return "The request cannot be made on a Proxy session";
    case WININET_E_REGISTRY_VALUE_NOT_FOUND                                       : return "The registry value could not be found";
    case WININET_E_BAD_REGISTRY_PARAMETER                                         : return "The registry parameter is incorrect";
    case WININET_E_NO_DIRECT_ACCESS                                               : return "Direct Internet access is not available";
    case WININET_E_NO_CONTEXT                                                     : return "No context value was supplied";
    case WININET_E_NO_CALLBACK                                                    : return "No status callback was supplied";
    case WININET_E_REQUEST_PENDING                                                : return "There are outstanding requests";
    case WININET_E_INCORRECT_FORMAT                                               : return "The information format is incorrect";
    case WININET_E_ITEM_NOT_FOUND                                                 : return "The requested item could not be found";
    case WININET_E_CANNOT_CONNECT                                                 : return "A connection with the server could not be established";
    case WININET_E_CONNECTION_ABORTED                                             : return "The connection with the server was terminated abnormally";
    case WININET_E_CONNECTION_RESET                                               : return "The connection with the server was reset";
    case WININET_E_FORCE_RETRY                                                    : return "The action must be retried";
    case WININET_E_INVALID_PROXY_REQUEST                                          : return "The proxy request is invalid";
    case WININET_E_NEED_UI                                                        : return "User interaction is required to complete the operation";
    case WININET_E_HANDLE_EXISTS                                                  : return "The handle already exists";
    case WININET_E_SEC_CERT_DATE_INVALID                                          : return "The date in the certificate is invalid or has expired";
    case WININET_E_SEC_CERT_CN_INVALID                                            : return "The host name in the certificate is invalid or does not match";
    case WININET_E_HTTP_TO_HTTPS_ON_REDIR                                         : return "A redirect request will change a non-secure to a secure connection";
    case WININET_E_HTTPS_TO_HTTP_ON_REDIR                                         : return "A redirect request will change a secure to a non-secure connection";
    case WININET_E_MIXED_SECURITY                                                 : return "Mixed secure and non-secure connections";
    case WININET_E_CHG_POST_IS_NON_SECURE                                         : return "Changing to non-secure post";
    case WININET_E_POST_IS_NON_SECURE                                             : return "Data is being posted on a non-secure connection";
    case WININET_E_CLIENT_AUTH_CERT_NEEDED                                        : return "A certificate is required to complete client authentication";
    case WININET_E_INVALID_CA                                                     : return "The certificate authority is invalid or incorrect";
    case WININET_E_CLIENT_AUTH_NOT_SETUP                                          : return "Client authentication has not been correctly installed";
    case WININET_E_ASYNC_THREAD_FAILED                                            : return "An error has occurred in a Wininet asynchronous thread. You may need to restart";
    case WININET_E_REDIRECT_SCHEME_CHANGE                                         : return "The protocol scheme has changed during a redirect operaiton";
    case WININET_E_DIALOG_PENDING                                                 : return "There are operations awaiting retry";
    case WININET_E_RETRY_DIALOG                                                   : return "The operation must be retried";
    case WININET_E_NO_NEW_CONTAINERS                                              : return "There are no new cache containers";
    case WININET_E_HTTPS_HTTP_SUBMIT_REDIR                                        : return "A security zone check indicates the operation must be retried";
    case WININET_E_SEC_CERT_ERRORS                                                : return "The SSL certificate contains errors";
    case WININET_E_SEC_CERT_REV_FAILED                                            : return "It was not possible to connect to the revocation server or a definitive response could not be obtained";
    case WININET_E_HEADER_NOT_FOUND                                               : return "The requested header was not found";
    case WININET_E_DOWNLEVEL_SERVER                                               : return "The server does not support the requested protocol level";
    case WININET_E_INVALID_SERVER_RESPONSE                                        : return "The server returned an invalid or unrecognized response";
    case WININET_E_INVALID_HEADER                                                 : return "The supplied HTTP header is invalid";
    case WININET_E_INVALID_QUERY_REQUEST                                          : return "The request for a HTTP header is invalid";
    case WININET_E_HEADER_ALREADY_EXISTS                                          : return "The HTTP header already exists";
    case WININET_E_REDIRECT_FAILED                                                : return "The HTTP redirect request failed";
    case WININET_E_SECURITY_CHANNEL_ERROR                                         : return "An error occurred in the secure channel support";
    case WININET_E_UNABLE_TO_CACHE_FILE                                           : return "The file could not be written to the cache";
    case WININET_E_TCPIP_NOT_INSTALLED                                            : return "The TCP/IP protocol is not installed properly";
    case WININET_E_DISCONNECTED                                                   : return "The computer is disconnected from the network";
    case WININET_E_SERVER_UNREACHABLE                                             : return "The server is unreachable";
    case WININET_E_PROXY_SERVER_UNREACHABLE                                       : return "The proxy server is unreachable";
    case WININET_E_BAD_AUTO_PROXY_SCRIPT                                          : return "The proxy auto-configuration script is in error";
    case WININET_E_UNABLE_TO_DOWNLOAD_SCRIPT                                      : return "Could not download the proxy auto-configuration script file";
    case WININET_E_SEC_INVALID_CERT                                               : return "The supplied certificate is invalid";
    case WININET_E_SEC_CERT_REVOKED                                               : return "The supplied certificate has been revoked";
    case WININET_E_FAILED_DUETOSECURITYCHECK                                      : return "The Dialup failed because file sharing was turned on and a failure was requested if security check was needed";
    case WININET_E_NOT_INITIALIZED                                                : return "Initialization of the WinINet API has not occurred";
    case WININET_E_LOGIN_FAILURE_DISPLAY_ENTITY_BODY                              : return "Login failed and the client should display the entity body to the user";
    case WININET_E_DECODING_FAILED                                                : return "Content decoding has failed";
    case WININET_E_NOT_REDIRECTED                                                 : return "The HTTP request was not redirected";
    case WININET_E_COOKIE_NEEDS_CONFIRMATION                                      : return "A cookie from the server must be confirmed by the user";
    case WININET_E_COOKIE_DECLINED                                                : return "A cookie from the server has been declined acceptance";
    case WININET_E_REDIRECT_NEEDS_CONFIRMATION                                    : return "The HTTP redirect request must be confirmed by the user";
    case SQLITE_E_ERROR                                                           : return "SQL error or missing database";
    case SQLITE_E_INTERNAL                                                        : return "Internal logic error in SQLite";
    case SQLITE_E_PERM                                                            : return "Access permission denied";
    case SQLITE_E_ABORT                                                           : return "Callback routine requested an abort";
    case SQLITE_E_BUSY                                                            : return "The database file is locked";
    case SQLITE_E_LOCKED                                                          : return "A table in the database is locked";
    case SQLITE_E_NOMEM                                                           : return "A malloc() failed";
    case SQLITE_E_READONLY                                                        : return "Attempt to write a readonly database";
    case SQLITE_E_INTERRUPT                                                       : return "Operation terminated by sqlite3_interrupt()";
    case SQLITE_E_IOERR                                                           : return "Some kind of disk I/O error occurred";
    case SQLITE_E_CORRUPT                                                         : return "The database disk image is malformed";
    case SQLITE_E_NOTFOUND                                                        : return "Unknown opcode in sqlite3_file_control()";
    case SQLITE_E_FULL                                                            : return "Insertion failed because database is full";
    case SQLITE_E_CANTOPEN                                                        : return "Unable to open the database file";
    case SQLITE_E_PROTOCOL                                                        : return "Database lock protocol error";
    case SQLITE_E_EMPTY                                                           : return "Database is empty";
    case SQLITE_E_SCHEMA                                                          : return "The database schema changed";
    case SQLITE_E_TOOBIG                                                          : return "String or BLOB exceeds size limit";
    case SQLITE_E_CONSTRAINT                                                      : return "Abort due to constraint violation";
    case SQLITE_E_MISMATCH                                                        : return "Data type mismatch";
    case SQLITE_E_MISUSE                                                          : return "Library used incorrectly";
    case SQLITE_E_NOLFS                                                           : return "Uses OS features not supported on host";
    case SQLITE_E_AUTH                                                            : return "Authorization denied";
    case SQLITE_E_FORMAT                                                          : return "Auxiliary database format error";
    case SQLITE_E_RANGE                                                           : return "2nd parameter to sqlite3_bind out of range";
    case SQLITE_E_NOTADB                                                          : return "File opened that is not a database file";
    case SQLITE_E_NOTICE                                                          : return "Notifications from sqlite3_log()";
    case SQLITE_E_WARNING                                                         : return "Warnings from sqlite3_log()";
    case SQLITE_E_ROW                                                             : return "sqlite3_step() has another row ready";
    case SQLITE_E_DONE                                                            : return "sqlite3_step() has finished executing";
    case SQLITE_E_IOERR_READ                                                      : return "SQLITE_IOERR_READ";
    case SQLITE_E_IOERR_SHORT_READ                                                : return "SQLITE_IOERR_SHORT_READ";
    case SQLITE_E_IOERR_WRITE                                                     : return "SQLITE_IOERR_WRITE";
    case SQLITE_E_IOERR_FSYNC                                                     : return "SQLITE_IOERR_FSYNC";
    case SQLITE_E_IOERR_DIR_FSYNC                                                 : return "SQLITE_IOERR_DIR_FSYNC";
    case SQLITE_E_IOERR_TRUNCATE                                                  : return "SQLITE_IOERR_TRUNCATE";
    case SQLITE_E_IOERR_FSTAT                                                     : return "SQLITE_IOERR_FSTAT";
    case SQLITE_E_IOERR_UNLOCK                                                    : return "SQLITE_IOERR_UNLOCK";
    case SQLITE_E_IOERR_RDLOCK                                                    : return "SQLITE_IOERR_RDLOCK";
    case SQLITE_E_IOERR_DELETE                                                    : return "SQLITE_IOERR_DELETE";
    case SQLITE_E_IOERR_BLOCKED                                                   : return "SQLITE_IOERR_BLOCKED";
    case SQLITE_E_IOERR_NOMEM                                                     : return "SQLITE_IOERR_NOMEM";
    case SQLITE_E_IOERR_ACCESS                                                    : return "SQLITE_IOERR_ACCESS";
    case SQLITE_E_IOERR_CHECKRESERVEDLOCK                                         : return "SQLITE_IOERR_CHECKRESERVEDLOCK";
    case SQLITE_E_IOERR_LOCK                                                      : return "SQLITE_IOERR_LOCK";
    case SQLITE_E_IOERR_CLOSE                                                     : return "SQLITE_IOERR_CLOSE";
    case SQLITE_E_IOERR_DIR_CLOSE                                                 : return "SQLITE_IOERR_DIR_CLOSE";
    case SQLITE_E_IOERR_SHMOPEN                                                   : return "SQLITE_IOERR_SHMOPEN";
    case SQLITE_E_IOERR_SHMSIZE                                                   : return "SQLITE_IOERR_SHMSIZE";
    case SQLITE_E_IOERR_SHMLOCK                                                   : return "SQLITE_IOERR_SHMLOCK";
    case SQLITE_E_IOERR_SHMMAP                                                    : return "SQLITE_IOERR_SHMMAP";
    case SQLITE_E_IOERR_SEEK                                                      : return "SQLITE_IOERR_SEEK";
    case SQLITE_E_IOERR_DELETE_NOENT                                              : return "SQLITE_IOERR_DELETE_NOENT";
    case SQLITE_E_IOERR_MMAP                                                      : return "SQLITE_IOERR_MMAP";
    case SQLITE_E_IOERR_GETTEMPPATH                                               : return "SQLITE_IOERR_GETTEMPPATH";
    case SQLITE_E_IOERR_CONVPATH                                                  : return "SQLITE_IOERR_CONVPATH";
    case SQLITE_E_IOERR_VNODE                                                     : return "SQLITE_IOERR_VNODE";
    case SQLITE_E_IOERR_AUTH                                                      : return "SQLITE_IOERR_AUTH";
    case SQLITE_E_LOCKED_SHAREDCACHE                                              : return "SQLITE_LOCKED_SHAREDCACHE";
    case SQLITE_E_BUSY_RECOVERY                                                   : return "SQLITE_BUSY_RECOVERY";
    case SQLITE_E_BUSY_SNAPSHOT                                                   : return "SQLITE_BUSY_SNAPSHOT";
    case SQLITE_E_CANTOPEN_NOTEMPDIR                                              : return "SQLITE_CANTOPEN_NOTEMPDIR";
    case SQLITE_E_CANTOPEN_ISDIR                                                  : return "SQLITE_CANTOPEN_ISDIR";
    case SQLITE_E_CANTOPEN_FULLPATH                                               : return "SQLITE_CANTOPEN_FULLPATH";
    case SQLITE_E_CANTOPEN_CONVPATH                                               : return "SQLITE_CANTOPEN_CONVPATH";
    case SQLITE_E_CORRUPT_VTAB                                                    : return "SQLITE_CORRUPT_VTAB";
    case SQLITE_E_READONLY_RECOVERY                                               : return "SQLITE_READONLY_RECOVERY";
    case SQLITE_E_READONLY_CANTLOCK                                               : return "SQLITE_READONLY_CANTLOCK";
    case SQLITE_E_READONLY_ROLLBACK                                               : return "SQLITE_READONLY_ROLLBACK";
    case SQLITE_E_READONLY_DBMOVED                                                : return "SQLITE_READONLY_DBMOVED";
    case SQLITE_E_ABORT_ROLLBACK                                                  : return "SQLITE_ABORT_ROLLBACK";
    case SQLITE_E_CONSTRAINT_CHECK                                                : return "SQLITE_CONSTRAINT_CHECK";
    case SQLITE_E_CONSTRAINT_COMMITHOOK                                           : return "SQLITE_CONSTRAINT_COMMITHOOK";
    case SQLITE_E_CONSTRAINT_FOREIGNKEY                                           : return "SQLITE_CONSTRAINT_FOREIGNKEY";
    case SQLITE_E_CONSTRAINT_FUNCTION                                             : return "SQLITE_CONSTRAINT_FUNCTION";
    case SQLITE_E_CONSTRAINT_NOTNULL                                              : return "SQLITE_CONSTRAINT_NOTNULL";
    case SQLITE_E_CONSTRAINT_PRIMARYKEY                                           : return "SQLITE_CONSTRAINT_PRIMARYKEY";
    case SQLITE_E_CONSTRAINT_TRIGGER                                              : return "SQLITE_CONSTRAINT_TRIGGER";
    case SQLITE_E_CONSTRAINT_UNIQUE                                               : return "SQLITE_CONSTRAINT_UNIQUE";
    case SQLITE_E_CONSTRAINT_VTAB                                                 : return "SQLITE_CONSTRAINT_VTAB";
    case SQLITE_E_CONSTRAINT_ROWID                                                : return "SQLITE_CONSTRAINT_ROWID";
    case SQLITE_E_NOTICE_RECOVER_WAL                                              : return "SQLITE_NOTICE_RECOVER_WAL";
    case SQLITE_E_NOTICE_RECOVER_ROLLBACK                                         : return "SQLITE_NOTICE_RECOVER_ROLLBACK";
    case SQLITE_E_WARNING_AUTOINDEX                                               : return "SQLITE_WARNING_AUTOINDEX";
    case UTC_E_TOGGLE_TRACE_STARTED                                               : return "Toggle (alternative) trace started";
    case UTC_E_ALTERNATIVE_TRACE_CANNOT_PREEMPT                                   : return "Cannot pre-empt running trace: The current trace has a higher priority";
    case UTC_E_AOT_NOT_RUNNING                                                    : return "The always-on-trace is not running";
    case UTC_E_SCRIPT_TYPE_INVALID                                                : return "RunScriptAction contains an invalid script type";
    case UTC_E_SCENARIODEF_NOT_FOUND                                              : return "Requested scenario definition cannot be found";
    case UTC_E_TRACEPROFILE_NOT_FOUND                                             : return "Requested trace profile cannot be found";
    case UTC_E_FORWARDER_ALREADY_ENABLED                                          : return "Trigger forwarder is already enabled";
    case UTC_E_FORWARDER_ALREADY_DISABLED                                         : return "Trigger forwarder is already disabled";
    case UTC_E_EVENTLOG_ENTRY_MALFORMED                                           : return "Cannot parse EventLog XML: The entry is malformed";
    case UTC_E_DIAGRULES_SCHEMAVERSION_MISMATCH                                   : return "<diagrules> node contains a schemaversion which is not compatible with this client";
    case UTC_E_SCRIPT_TERMINATED                                                  : return "RunScriptAction was forced to terminate a script";
    case UTC_E_INVALID_CUSTOM_FILTER                                              : return "ToggleTraceWithCustomFilterAction contains an invalid custom filter";
    case UTC_E_TRACE_NOT_RUNNING                                                  : return "The trace is not running";
    case UTC_E_REESCALATED_TOO_QUICKLY                                            : return "A scenario failed to escalate: This scenario has escalated too recently";
    case UTC_E_ESCALATION_ALREADY_RUNNING                                         : return "A scenario failed to escalate: This scenario is already running an escalation";
    case UTC_E_PERFTRACK_ALREADY_TRACING                                          : return "Cannot start tracing: PerfTrack component is already tracing";
    case UTC_E_REACHED_MAX_ESCALATIONS                                            : return "A scenario failed to escalate: This scenario has reached max escalations for this escalation type";
    case UTC_E_FORWARDER_PRODUCER_MISMATCH                                        : return "Cannot update forwarder: The forwarder passed to the function is of a different type";
    case UTC_E_INTENTIONAL_SCRIPT_FAILURE                                         : return "RunScriptAction failed intentionally to force this escalation to terminate";
    case UTC_E_SQM_INIT_FAILED                                                    : return "Failed to initialize SQM logger";
    case UTC_E_NO_WER_LOGGER_SUPPORTED                                            : return "Failed to initialize WER logger: This system does not support WER for UTC";
    case UTC_E_TRACERS_DONT_EXIST                                                 : return "The TraceManager has attempted to take a tracing action without initializing tracers";
    case UTC_E_WINRT_INIT_FAILED                                                  : return "WinRT initialization failed";
    case UTC_E_SCENARIODEF_SCHEMAVERSION_MISMATCH                                 : return "<scenario> node contains a schemaversion that is not compatible with this client";
    case UTC_E_INVALID_FILTER                                                     : return "Scenario contains an invalid filter that can never be satisfied";
    case UTC_E_EXE_TERMINATED                                                     : return "RunExeWithArgsAction was forced to terminate a running executable";
    case UTC_E_ESCALATION_NOT_AUTHORIZED                                          : return "Escalation for scenario failed due to insufficient permissions";
    case UTC_E_SETUP_NOT_AUTHORIZED                                               : return "Setup for scenario failed due to insufficient permissions";
    case UTC_E_CHILD_PROCESS_FAILED                                               : return "A process launched by UTC failed with a non-zero exit code";
    case UTC_E_COMMAND_LINE_NOT_AUTHORIZED                                        : return "A RunExeWithArgs action contains an unauthorized command line";
    case UTC_E_CANNOT_LOAD_SCENARIO_EDITOR_XML                                    : return "UTC cannot load Scenario Editor XML. Convert the scenario file to a DiagTrack XML using the editor";
    case UTC_E_ESCALATION_TIMED_OUT                                               : return "Escalation for scenario has timed out";
    case UTC_E_SETUP_TIMED_OUT                                                    : return "Setup for scenario has timed out";
    case UTC_E_TRIGGER_MISMATCH                                                   : return "The given trigger does not match the expected trigger type";
    case UTC_E_TRIGGER_NOT_FOUND                                                  : return "Requested trigger cannot be found";
    case UTC_E_SIF_NOT_SUPPORTED                                                  : return "SIF is not supported on the machine";
    case UTC_E_DELAY_TERMINATED                                                   : return "The delay action was terminated";
    case UTC_E_DEVICE_TICKET_ERROR                                                : return "The device ticket was not obtained";
    case UTC_E_TRACE_BUFFER_LIMIT_EXCEEDED                                        : return "The trace profile needs more memory than is available for tracing";
    case UTC_E_API_RESULT_UNAVAILABLE                                             : return "The API was not completed successfully so the result is unavailable";
    case UTC_E_RPC_TIMEOUT                                                        : return "The requested API encountered a timeout in the API manager";
    case UTC_E_RPC_WAIT_FAILED                                                    : return "The synchronous API encountered a wait failure";
    case UTC_E_API_BUSY                                                           : return "The UTC API is busy with another request";
    case UTC_E_TRACE_MIN_DURATION_REQUIREMENT_NOT_MET                             : return "The running trace profile does not have a sufficient runtime to fulfill the escalation request";
    case UTC_E_EXCLUSIVITY_NOT_AVAILABLE                                          : return "The trace profile could not be started because it requires exclusivity and another higher priority trace is already running";
    case UTC_E_GETFILE_FILE_PATH_NOT_APPROVED                                     : return "The file path is not approved for the GetFile escalation action";
    case UTC_E_ESCALATION_DIRECTORY_ALREADY_EXISTS                                : return "The escalation working directory for the requested escalation could not be created because it already exists";
    case UTC_E_TIME_TRIGGER_ON_START_INVALID                                      : return "Time triggers cannot be used on a transition originating from the \"_start\" state";
    case UTC_E_TIME_TRIGGER_ONLY_VALID_ON_SINGLE_TRANSITION                       : return "Time triggers can only be attached to a single transition";
    case UTC_E_TIME_TRIGGER_INVALID_TIME_RANGE                                    : return "Time trigger duration must fall within an inclusive range of one second and 15 minutes";
    case UTC_E_MULTIPLE_TIME_TRIGGER_ON_SINGLE_STATE                              : return "Only one Time Trigger is allowed per state";
    case UTC_E_BINARY_MISSING                                                     : return "A RunExeWithArgs action contains a binary which is not present on the targeted device";
    case UTC_E_NETWORK_CAPTURE_NOT_ALLOWED                                        : return "A network capture trace is not allowed";
    case UTC_E_FAILED_TO_RESOLVE_CONTAINER_ID                                     : return "UTC failed to identify the container id to use for a scenario escalation action";
    case UTC_E_UNABLE_TO_RESOLVE_SESSION                                          : return "Failed to resolve session ID during API invocation";
    case UTC_E_THROTTLED                                                          : return "UTC has throttled the event for firing too often";
    case UTC_E_UNAPPROVED_SCRIPT                                                  : return "The script is not approved to run as part of DiagTrack scenario";
    case UTC_E_SCRIPT_MISSING                                                     : return "The script referenced in DiagTrack scenario is not present on the system";
    case UTC_E_SCENARIO_THROTTLED                                                 : return "A trigger in this scenario is throttled, blocking the scenario from being loaded";
    case UTC_E_API_NOT_SUPPORTED                                                  : return "The requested UTC API call is not supported on this device";
    case UTC_E_GETFILE_EXTERNAL_PATH_NOT_APPROVED                                 : return "The file path is not approved for collection on external rings for the GetFile escalation action";
    case UTC_E_TRY_GET_SCENARIO_TIMEOUT_EXCEEDED                                  : return "Querying a scenario definition exceeded the specified maximum timeout";
    }

    return "The aliens are coming, Go tell your favorite people";
}

#undef  DWORD

#endif
